Meta-PR: More # optional doctest tags

src/sage/arith/functions.pyx

@@ -39,17 +39,17 @@ def lcm(a, b=None):
 
     EXAMPLES::
 
-        sage: lcm(97,100)
+        sage: lcm(97, 100)
         9700
-        sage: LCM(97,100)
+        sage: LCM(97, 100)
         9700
-        sage: LCM(0,2)
+        sage: LCM(0, 2)
         0
-        sage: LCM(-3,-5)
+        sage: LCM(-3, -5)
         15
         sage: LCM([1,2,3,4,5])
         60
-        sage: v = LCM(range(1,10000))   # *very* fast!
+        sage: v = LCM(range(1, 10000))   # *very* fast!
         sage: len(str(v))
         4349
 
@@ -72,25 +72,25 @@ def lcm(a, b=None):
 
     Make sure we try `\QQ` and not merely `\ZZ` (:trac:`13014`)::
 
-        sage: bool(lcm(2/5, 3/7) == lcm(SR(2/5), SR(3/7)))
+        sage: bool(lcm(2/5, 3/7) == lcm(SR(2/5), SR(3/7)))                              # optional - sage.symbolic
         True
 
     Make sure that the lcm of Expressions stays symbolic::
 
         sage: parent(lcm(2, 4))
         Integer Ring
-        sage: parent(lcm(SR(2), 4))
+        sage: parent(lcm(SR(2), 4))                                                     # optional - sage.symbolic
         Symbolic Ring
-        sage: parent(lcm(2, SR(4)))
+        sage: parent(lcm(2, SR(4)))                                                     # optional - sage.symbolic
         Symbolic Ring
-        sage: parent(lcm(SR(2), SR(4)))
+        sage: parent(lcm(SR(2), SR(4)))                                                 # optional - sage.symbolic
         Symbolic Ring
 
     Verify that objects without lcm methods but which can't be
     coerced to `\ZZ` or `\QQ` raise an error::
 
-        sage: F.<x,y> = FreeMonoid(2)
-        sage: lcm(x,y)
+        sage: F.<x,y> = FreeMonoid(2)                                                   # optional - sage.groups
+        sage: lcm(x,y)                                                                  # optional - sage.groups
         Traceback (most recent call last):
         ...
         TypeError: unable to find lcm of x and y

src/sage/arith/multi_modular.pyx

@@ -1,3 +1,4 @@
+# sage.doctest: optional - primecountpy
 """
 Utility classes for multi-modular algorithms
 """

src/sage/calculus/riemann.pyx

@@ -1190,10 +1190,11 @@ cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2] z_values,
     EXAMPLES::
 
         sage: from sage.calculus.riemann import complex_to_spiderweb
-        sage: import numpy
-        sage: zval = numpy.array([[0, 1, 1000],[.2+.3j,1,-.3j],[0,0,0]],dtype = numpy.complex128)
-        sage: deriv = numpy.array([[.1]],dtype = numpy.float64)
-        sage: complex_to_spiderweb(zval, deriv,deriv, 4,4,[0,0,0],1,False,0.001)
+        sage: import numpy                                                              # optional - numpy
+        sage: zval = numpy.array([[0,1,1000], [.2+.3j,1,-.3j], [0,0,0]],                # optional - numpy
+        ....:                    dtype=numpy.complex128)
+        sage: deriv = numpy.array([[.1]],dtype = numpy.float64)                         # optional - numpy
+        sage: complex_to_spiderweb(zval, deriv, deriv, 4, 4, [0,0,0], 1, False, 0.001)  # optional - numpy
         array([[[1., 1., 1.],
                 [1., 1., 1.],
                 [1., 1., 1.]],
@@ -1206,7 +1207,7 @@ cpdef complex_to_spiderweb(np.ndarray[COMPLEX_T, ndim = 2] z_values,
                 [1., 1., 1.],
                 [1., 1., 1.]]])
 
-        sage: complex_to_spiderweb(zval, deriv,deriv, 4,4,[0,0,0],1,True,0.001)
+        sage: complex_to_spiderweb(zval, deriv, deriv, 4, 4, [0,0,0], 1, True, 0.001)   # optional - numpy
         array([[[1.        , 1.        , 1.        ],
                 [1.        , 0.05558355, 0.05558355],
                 [0.17301243, 0.        , 0.        ]],
@@ -1280,13 +1281,13 @@ cpdef complex_to_rgb(np.ndarray[COMPLEX_T, ndim = 2] z_values):
     EXAMPLES::
 
         sage: from sage.calculus.riemann import complex_to_rgb
-        sage: import numpy
-        sage: complex_to_rgb(numpy.array([[0, 1, 1000]], dtype = numpy.complex128))
+        sage: import numpy                                                              # optional - numpy
+        sage: complex_to_rgb(numpy.array([[0, 1, 1000]], dtype=numpy.complex128))       # optional - numpy
         array([[[1.        , 1.        , 1.        ],
                 [1.        , 0.05558355, 0.05558355],
                 [0.17301243, 0.        , 0.        ]]])
 
-        sage: complex_to_rgb(numpy.array([[0, 1j, 1000j]], dtype = numpy.complex128))
+        sage: complex_to_rgb(numpy.array([[0, 1j, 1000j]], dtype=numpy.complex128))     # optional - numpy
         array([[[1.        , 1.        , 1.        ],
                 [0.52779177, 1.        , 0.05558355],
                 [0.08650622, 0.17301243, 0.        ]]])

src/sage/calculus/test_sympy.py

@@ -102,98 +102,98 @@
 
 And here are some actual tests of sympy::
 
-    sage: from sympy import Symbol, cos, sympify, pprint
-    sage: from sympy.abc import x
+    sage: from sympy import Symbol, cos, sympify, pprint                                # optional - sympy
+    sage: from sympy.abc import x                                                       # optional - sympy
 
 ::
 
-    sage: e = (1/cos(x)^3)._sympy_(); e
+    sage: e = (1/cos(x)^3)._sympy_(); e                                                 # optional - sympy
     cos(x)**(-3)
-    sage: f = e.series(x, 0, int(10)); f
+    sage: f = e.series(x, 0, int(10)); f                                                # optional - sympy
     1 + 3*x**2/2 + 11*x**4/8 + 241*x**6/240 + 8651*x**8/13440 + O(x**10)
 
 And the pretty-printer.  Since unicode characters are not working on
 some architectures, we disable it::
 
-    sage: from sympy.printing import pprint_use_unicode
-    sage: prev_use = pprint_use_unicode(False)
-    sage: pprint(e)
+    sage: from sympy.printing import pprint_use_unicode                                 # optional - sympy
+    sage: prev_use = pprint_use_unicode(False)                                          # optional - sympy
+    sage: pprint(e)                                                                     # optional - sympy
        1
     -------
        3
     cos (x)
 
-    sage: pprint(f)
+    sage: pprint(f)                                                                     # optional - sympy
            2       4        6         8
         3*x    11*x    241*x    8651*x     / 10\
     1 + ---- + ----- + ------ + ------- + O\x  /
          2       8      240      13440
-    sage: pprint_use_unicode(prev_use)
+    sage: pprint_use_unicode(prev_use)                                                  # optional - sympy
     False
 
 And the functionality to convert from sympy format to Sage format::
 
-    sage: e._sage_()
+    sage: e._sage_()                                                                    # optional - sympy
     cos(x)^(-3)
-    sage: e._sage_().taylor(x._sage_(), 0, 8)
+    sage: e._sage_().taylor(x._sage_(), 0, 8)                                           # optional - sympy
     8651/13440*x^8 + 241/240*x^6 + 11/8*x^4 + 3/2*x^2 + 1
-    sage: f._sage_()
+    sage: f._sage_()                                                                    # optional - sympy
     8651/13440*x^8 + 241/240*x^6 + 11/8*x^4 + 3/2*x^2 + Order(x^10) + 1
 
 Mixing SymPy with Sage::
 
-    sage: import sympy
-    sage: var("x")._sympy_() + var("y")._sympy_()
+    sage: import sympy                                                                  # optional - sympy
+    sage: var("x")._sympy_() + var("y")._sympy_()                                       # optional - sympy
     x + y
-    sage: o = var("omega")
-    sage: s = sympy.Symbol("x")
-    sage: t1 = s + o
-    sage: t2 = o + s
-    sage: type(t1)
+    sage: o = var("omega")                                                              # optional - sympy
+    sage: s = sympy.Symbol("x")                                                         # optional - sympy
+    sage: t1 = s + o                                                                    # optional - sympy
+    sage: t2 = o + s                                                                    # optional - sympy
+    sage: type(t1)                                                                      # optional - sympy
     <class 'sympy.core.add.Add'>
-    sage: type(t2)
+    sage: type(t2)                                                                      # optional - sympy
     <class 'sage.symbolic.expression.Expression'>
-    sage: t1, t2
+    sage: t1, t2                                                                        # optional - sympy
     (omega + x, omega + x)
-    sage: e=sympy.sin(var("y"))+sage.all.cos(sympy.Symbol("x"))
-    sage: type(e)
+    sage: e = sympy.sin(var("y"))+sage.all.cos(sympy.Symbol("x"))                       # optional - sympy
+    sage: type(e)                                                                       # optional - sympy
     <class 'sympy.core.add.Add'>
-    sage: e
+    sage: e                                                                             # optional - sympy
     sin(y) + cos(x)
-    sage: e=e._sage_()
-    sage: type(e)
+    sage: e=e._sage_()                                                                  # optional - sympy
+    sage: type(e)                                                                       # optional - sympy
     <class 'sage.symbolic.expression.Expression'>
-    sage: e
+    sage: e                                                                             # optional - sympy
     cos(x) + sin(y)
-    sage: e = sage.all.cos(var("y")**3)**4+var("x")**2
-    sage: e = e._sympy_()
-    sage: e
+    sage: e = sage.all.cos(var("y")**3)**4+var("x")**2                                  # optional - sympy
+    sage: e = e._sympy_()                                                               # optional - sympy
+    sage: e                                                                             # optional - sympy
     x**2 + cos(y**3)**4
 
 ::
 
-    sage: a = sympy.Matrix([1, 2, 3])
-    sage: a[1]
+    sage: a = sympy.Matrix([1, 2, 3])                                                   # optional - sympy
+    sage: a[1]                                                                          # optional - sympy
     2
 
 ::
 
-    sage: sympify(1.5)
+    sage: sympify(1.5)                                                                  # optional - sympy
     1.50000000000000
-    sage: sympify(2)
+    sage: sympify(2)                                                                    # optional - sympy
     2
-    sage: sympify(-2)
+    sage: sympify(-2)                                                                   # optional - sympy
     -2
 
 TESTS:
 
 This was fixed in Sympy, see :trac:`14437`::
 
-    sage: from sympy import Function, Symbol, rsolve
-    sage: u = Function('u')
-    sage: n = Symbol('n', integer=True)
-    sage: f = u(n+2) - u(n+1) + u(n)/4
-    sage: expand(2**n * rsolve(f,u(n)))
+    sage: from sympy import Function, Symbol, rsolve                                    # optional - sympy
+    sage: u = Function('u')                                                             # optional - sympy
+    sage: n = Symbol('n', integer=True)                                                 # optional - sympy
+    sage: f = u(n+2) - u(n+1) + u(n)/4                                                  # optional - sympy
+    sage: expand(2**n * rsolve(f,u(n)))                                                 # optional - sympy
     2*C1*n + C0
 
 """

src/sage/categories/action.pyx

@@ -21,7 +21,8 @@ A group action `G \times S \rightarrow S` is a functor from `G` to Sets.
         sage: import gc
         sage: _ = gc.collect()
         sage: A
-        <repr(<sage.categories.action.Action at 0x...>) failed: RuntimeError: This action acted on a set that became garbage collected>
+        <repr(<sage.categories.action.Action at 0x...>) failed:
+         RuntimeError: This action acted on a set that became garbage collected>
 
     To avoid garbage collection of the underlying set, it is sufficient to
     create a strong reference to it before the action is created.
@@ -265,15 +266,17 @@ cdef class Action(Functor):
             sage: R = (ZZ['x'])['y']
             sage: A = R.get_action(P,operator.mul,True)
             sage: A                 # indirect doctest
-            Right scalar multiplication by Univariate Polynomial Ring in x over
-            Rational Field on Univariate Polynomial Ring in y over Univariate
-            Polynomial Ring in x over Integer Ring
+            Right scalar multiplication
+             by Univariate Polynomial Ring in x over Rational Field
+             on Univariate Polynomial Ring in y over
+                 Univariate Polynomial Ring in x over Integer Ring
 
         In this example, the underlying set is the ring ``R``. This is the same
         as the left domain, which is different from the codomain of the action::
 
             sage: A.codomain()
-            Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field
+            Univariate Polynomial Ring in y
+             over Univariate Polynomial Ring in x over Rational Field
             sage: A.codomain() == R
             False
             sage: A.left_domain() is R
@@ -294,7 +297,8 @@ cdef class Action(Functor):
             sage: import gc
             sage: _ = gc.collect()
             sage: A
-            <repr(<sage.categories.action.Action at 0x...>) failed: RuntimeError: This action acted on a set that became garbage collected>
+            <repr(<sage.categories.action.Action at 0x...>) failed:
+             RuntimeError: This action acted on a set that became garbage collected>
         """
         S = self.US()
         if S is None:
@@ -329,24 +333,28 @@ cdef class InverseAction(Action):
 
     EXAMPLES::
 
-        sage: V = QQ^3
-        sage: v = V((1, 2, 3))
+        sage: V = QQ^3                                                                  # optional - sage.modules
+        sage: v = V((1, 2, 3))                                                          # optional - sage.modules
         sage: cm = get_coercion_model()
 
-        sage: a = cm.get_action(V, QQ, operator.mul)
-        sage: a
-        Right scalar multiplication by Rational Field on Vector space of dimension 3 over Rational Field
-        sage: ~a
-        Right inverse action by Rational Field on Vector space of dimension 3 over Rational Field
-        sage: (~a)(v, 1/3)
+        sage: a = cm.get_action(V, QQ, operator.mul)                                    # optional - sage.modules
+        sage: a                                                                         # optional - sage.modules
+        Right scalar multiplication by Rational Field
+         on Vector space of dimension 3 over Rational Field
+        sage: ~a                                                                        # optional - sage.modules
+        Right inverse action by Rational Field
+         on Vector space of dimension 3 over Rational Field
+        sage: (~a)(v, 1/3)                                                              # optional - sage.modules
         (3, 6, 9)
 
-        sage: b = cm.get_action(QQ, V, operator.mul)
-        sage: b
-        Left scalar multiplication by Rational Field on Vector space of dimension 3 over Rational Field
-        sage: ~b
-        Left inverse action by Rational Field on Vector space of dimension 3 over Rational Field
-        sage: (~b)(1/3, v)
+        sage: b = cm.get_action(QQ, V, operator.mul)                                    # optional - sage.modules
+        sage: b                                                                         # optional - sage.modules
+        Left scalar multiplication by Rational Field
+         on Vector space of dimension 3 over Rational Field
+        sage: ~b                                                                        # optional - sage.modules
+        Left inverse action by Rational Field
+         on Vector space of dimension 3 over Rational Field
+        sage: (~b)(1/3, v)                                                              # optional - sage.modules
         (3, 6, 9)
 
         sage: c = cm.get_action(ZZ, list, operator.mul)
@@ -390,11 +398,11 @@ cdef class InverseAction(Action):
 
         Check that this action can be pickled (:trac:`29031`)::
 
-            sage: V = QQ^3
-            sage: v = V((1, 2, 3))
-            sage: cm = get_coercion_model()
-            sage: a = cm.get_action(V, QQ, operator.mul)
-            sage: loads(dumps(~a)) is not None
+            sage: V = QQ^3                                                              # optional - sage.modules
+            sage: v = V((1, 2, 3))                                                      # optional - sage.modules
+            sage: cm = get_coercion_model()                                             # optional - sage.modules
+            sage: a = cm.get_action(V, QQ, operator.mul)                                # optional - sage.modules
+            sage: loads(dumps(~a)) is not None                                          # optional - sage.modules
             True
         """
         return (type(self), (self._action,))
@@ -434,8 +442,9 @@ cdef class PrecomposedAction(Action):
         sage: c,x = v[0]
         sage: y = x.modular_symbol_rep()
         sage: coercion_model.get_action(QQ, parent(y), op=operator.mul)
-        Left scalar multiplication by Rational Field on Abelian Group of all Formal Finite Sums over Rational Field
-        with precomposition on right by Coercion map:
+        Left scalar multiplication by Rational Field
+         on Abelian Group of all Formal Finite Sums over Rational Field
+         with precomposition on right by Coercion map:
           From: Abelian Group of all Formal Finite Sums over Integer Ring
           To:   Abelian Group of all Formal Finite Sums over Rational Field
     """
@@ -542,8 +551,8 @@ cdef class ActionEndomorphism(Morphism):
 
         sage: A = ZZ['x'].get_action(QQ, self_on_left=False, op=operator.mul)
         sage: A
-        Left scalar multiplication by Rational Field on Univariate Polynomial
-        Ring in x over Integer Ring
+        Left scalar multiplication by Rational Field
+         on Univariate Polynomial Ring in x over Integer Ring
         sage: A(1/2)
         Action of 1/2 on Univariate Polynomial Ring in x over Integer Ring
         under Left scalar multiplication by Rational Field on Univariate