Ticket #4539: plural-missing-docu.2.patch

File plural-missing-docu.2.patch, 21.0 KB (added by AlexanderDreyer, 4 years ago)
  • sage/algebras/free_algebra.py

    diff -r 6a696ae732ab sage/algebras/free_algebra.py
    a b  
    166166    """ 
    167167    def __init__(self, R, n, names): 
    168168        """ 
     169        The free algebra on `n` generators over a base ring. 
    169170        INPUT: 
    170171         
    171          
    172172        -  ``R`` - ring 
    173173         
    174174        -  ``n`` - an integer 
    175175         
    176176        -  ``names`` - generator names 
     177     
     178        EXAMPLES:: 
     179     
     180        sage: F.<x,y,z> = FreeAlgebra(QQ, 3); F # indirect doctet 
     181        Free Algebra on 3 generators (x, y, z) over Rational Field 
    177182        """ 
    178183        if not isinstance(R, Ring): 
    179184            raise TypeError, "Argument R must be a ring." 
     
    253258            sage: print F 
    254259            Free Algebra on 3 generators (x0, x1, x2) over Rational Field 
    255260            sage: F.rename('QQ<<x0,x1,x2>>') 
    256             sage: print F 
     261            sage: print F #indirect doctest 
    257262            QQ<<x0,x1,x2>> 
    258263        """ 
    259264        return "Free Algebra on %s generators %s over %s"%( 
     
    312317         
    313318        :: 
    314319         
    315             sage: F._coerce_(x*y) 
     320            sage: F._coerce_(x*y) # indirect doctest 
    316321            x*y 
    317322         
    318323        Elements of the integers coerce in, since there is a coerce map 
     
    383388        return self._coerce_try(x, [self.base_ring()]) 
    384389 
    385390    def coerce_map_from_impl(self, R): 
     391        """ 
     392        Elements of the free algebra canonically coerce in. 
     393 
     394        EXAMPLES:: 
     395         
     396        sage: F.<x,y,z> = FreeAlgebra(GF(7),3); F 
     397        Free Algebra on 3 generators (x, y, z) over Finite Field of size 7 
     398         
     399        sage: F._coerce_(x*y) # indirect doctest 
     400        x*y 
     401        """ 
     402             
    386403        if R is self.__monoid: 
    387404            return True 
    388405 
     
    421438        which form a free basis for the module of A, and a list of 
    422439        matrices, which give the action of the free generators of A on this 
    423440        monomial basis. 
     441        Quaternion algebra defined in terms of three generators:: 
     442         
     443        sage: n = 3 
     444        sage: A = FreeAlgebra(QQ,n,'i') 
     445        sage: F = A.monoid() 
     446        sage: i, j, k = F.gens() 
     447        sage: mons = [ F(1), i, j, k ] 
     448        sage: M = MatrixSpace(QQ,4) 
     449        sage: mats = [M([0,1,0,0, -1,0,0,0, 0,0,0,-1, 0,0,1,0]),  M([0,0,1,0, 0,0,0,1, -1,0,0,0, 0,-1,0,0]),  M([0,0,0,1, 0,0,-1,0, 0,1,0,0, -1,0,0,0]) ] 
     450        sage: H.<i,j,k> = A.quotient(mons, mats); H 
     451        Free algebra quotient on 3 generators ('i', 'j', 'k') and dimension 4 over Rational Field 
    424452        """ 
    425453        import free_algebra_quotient 
    426454        return free_algebra_quotient.FreeAlgebraQuotient(self, mons, mats, names) 
  • sage/libs/singular/function.pyx

    diff -r 6a696ae732ab sage/libs/singular/function.pyx
    a b  
    158158            self._ring.ref -= 1 
    159159 
    160160    def ngens(self): 
     161        """ 
     162        Get number of generators 
     163 
     164        EXAMPLE:: 
     165 
     166            sage: from sage.libs.singular.function import singular_function 
     167            sage: P.<x,y,z> = PolynomialRing(QQ) 
     168            sage: ringlist = singular_function("ringlist") 
     169            sage: l = ringlist(P) 
     170            sage: ring = singular_function("ring") 
     171            sage: ring(l, ring=P).ngens() 
     172            3 
     173        """ 
    161174        return self._ring.N 
    162175 
    163176    def var_names(self): 
     177        """ 
     178        Get name of variables 
     179 
     180        EXAMPLE:: 
     181 
     182            sage: from sage.libs.singular.function import singular_function 
     183            sage: P.<x,y,z> = PolynomialRing(QQ) 
     184            sage: ringlist = singular_function("ringlist") 
     185            sage: l = ringlist(P) 
     186            sage: ring = singular_function("ring") 
     187            sage: ring(l, ring=P).var_names() 
     188            ['x', 'y', 'z'] 
     189        """ 
    164190        return [self._ring.names[i] for i in range(self.ngens())] 
    165191 
    166192    def npars(self): 
     193        """ 
     194        Get number of parameters 
     195 
     196        EXAMPLE:: 
     197 
     198            sage: from sage.libs.singular.function import singular_function 
     199            sage: P.<x,y,z> = PolynomialRing(QQ) 
     200            sage: ringlist = singular_function("ringlist") 
     201            sage: l = ringlist(P) 
     202            sage: ring = singular_function("ring") 
     203            sage: ring(l, ring=P).npars() 
     204            0 
     205        """ 
    167206        return self._ring.P 
    168207 
    169208    def ordering_string(self): 
     209        """ 
     210        Get Singular string defining monomial ordering 
     211 
     212        EXAMPLE:: 
     213 
     214            sage: from sage.libs.singular.function import singular_function 
     215            sage: P.<x,y,z> = PolynomialRing(QQ) 
     216            sage: ringlist = singular_function("ringlist") 
     217            sage: l = ringlist(P) 
     218            sage: ring = singular_function("ring") 
     219            sage: ring(l, ring=P).ordering_string() 
     220            'dp(3),C' 
     221        """ 
    170222        return rOrderingString(self._ring) 
    171223     
    172224     
    173225 
    174226    def par_names(self): 
     227        """ 
     228        Get parameter names 
     229 
     230        EXAMPLE:: 
     231 
     232            sage: from sage.libs.singular.function import singular_function 
     233            sage: P.<x,y,z> = PolynomialRing(QQ) 
     234            sage: ringlist = singular_function("ringlist") 
     235            sage: l = ringlist(P) 
     236            sage: ring = singular_function("ring") 
     237            sage: ring(l, ring=P).par_names() 
     238            [] 
     239        """ 
    175240        return [self._ring.parameter[i] for i in range(self.npars())] 
    176241 
    177242    def characteristic(self): 
     243        """ 
     244        Get characteristic 
     245 
     246        EXAMPLE:: 
     247 
     248            sage: from sage.libs.singular.function import singular_function 
     249            sage: P.<x,y,z> = PolynomialRing(QQ) 
     250            sage: ringlist = singular_function("ringlist") 
     251            sage: l = ringlist(P) 
     252            sage: ring = singular_function("ring") 
     253            sage: ring(l, ring=P).characteristic() 
     254            0 
     255        """ 
    178256        return self._ring.ch 
    179257 
    180258    def is_commutative(self): 
     259        """ 
     260        Determine whether a given ring is  commutative 
     261 
     262        EXAMPLE:: 
     263 
     264            sage: from sage.libs.singular.function import singular_function 
     265            sage: P.<x,y,z> = PolynomialRing(QQ) 
     266            sage: ringlist = singular_function("ringlist") 
     267            sage: l = ringlist(P) 
     268            sage: ring = singular_function("ring") 
     269            sage: ring(l, ring=P).is_commutative() 
     270            True 
     271        """ 
    181272        return not rIsPluralRing(self._ring) 
    182273     
    183274    def _output(self): # , debug = False 
     275        """ 
     276        Use Singular output 
     277 
     278        EXAMPLE:: 
     279 
     280            sage: from sage.libs.singular.function import singular_function 
     281            sage: P.<x,y,z> = PolynomialRing(QQ) 
     282            sage: ringlist = singular_function("ringlist") 
     283            sage: l = ringlist(P) 
     284            sage: ring = singular_function("ring") 
     285            sage: ring(l, ring=P)._output() 
     286        """ 
    184287        rPrint(self._ring) 
    185288#        if debug: 
    186289#        rDebugPrint(self._ring) 
     
    266369# ===================================== 
    267370 
    268371def is_sage_wrapper_for_singular_ring(ring): 
     372    """ 
     373    Check whether wrapped ring arises from Singular or Singular/Plural 
     374 
     375    EXAMPLE:: 
     376 
     377    sage: from sage.libs.singular.function import is_sage_wrapper_for_singular_ring 
     378    sage: P.<x,y,z> = QQ[] 
     379    sage: is_sage_wrapper_for_singular_ring(P) 
     380    True 
     381 
     382    sage: A.<x,y,z> = FreeAlgebra(QQ, 3) 
     383    sage: P = A.g_algebra(relations={y*x:-x*y}, order = 'lex')  
     384    sage: is_sage_wrapper_for_singular_ring(P) 
     385    True 
     386 
     387    """ 
    269388    if PY_TYPE_CHECK(ring, MPolynomialRing_libsingular): 
    270389        return True 
    271390    if PY_TYPE_CHECK(ring, NCPolynomialRing_plural): 
     
    15271646        sage: len(l) 
    15281647        6 
    15291648        sage: ring(l, ring=P) 
    1530         <RingWrap> 
     1649        <noncommutative RingWrap> 
    15311650        sage: I=twostd(I) 
    15321651        sage: l[3]=I 
    15331652        sage: ring(l, ring=P) 
    1534         <RingWrap> 
     1653        <noncommutative RingWrap> 
    15351654         
    15361655    """ 
    15371656 
  • sage/rings/polynomial/multi_polynomial_ideal.py

    diff -r 6a696ae732ab sage/rings/polynomial/multi_polynomial_ideal.py
    a b  
    353353        sage: P.<a,b,c,d,e> = PolynomialRing(GF(127)) 
    354354        sage: J = sage.rings.ideal.Cyclic(P).homogenize() 
    355355        sage: from sage.misc.sageinspect import sage_getsource 
    356         sage: "buchberger" in sage_getsource(J.interreduced_basis) 
     356        sage: "buchberger" in sage_getsource(J.interreduced_basis) #indirect doctest 
    357357        True 
    358358 
    359359    .. note:: 
     
    451451        EXAMPLES:: 
    452452         
    453453            sage: R.<a,b,c,d,e,f,g,h,i,j> = PolynomialRing(GF(127),10) 
    454             sage: I = sage.rings.ideal.Cyclic(R,4) 
    455             sage: magma(I)                                          # optional - magma 
     454            sage: I = sage.rings.ideal.Cyclic(R,4) # indirect doctest 
     455            sage: magma(I)    # optional - magma 
    456456            Ideal of Polynomial ring of rank 10 over GF(127) 
    457457            Graded Reverse Lexicographical Order 
    458458            Variables: a, b, c, d, e, f, g, h, i, j 
     
    604604        return S 
    605605     
    606606 
    607 class MPolynomialIdeal_singular_commutative_repr( 
     607class MPolynomialIdeal_singular_repr( 
    608608        MPolynomialIdeal_singular_base_repr): 
    609609    """ 
    610610    An ideal in a multivariate polynomial ring, which has an 
     
    13491349            False 
    13501350        """ 
    13511351        R = self.ring() 
     1352 
    13521353        if not isinstance(other, MPolynomialIdeal_singular_repr) or other.ring() != R: 
    13531354            raise ValueError, "other must be an ideal in the ring of self, but it isn't." 
    13541355 
     
    21962197    def _macaulay2_(self, macaulay2=None): 
    21972198        """ 
    21982199        Return Macaulay2 ideal corresponding to this ideal. 
     2200    EXAMPLES:: 
     2201     
     2202        sage: R.<x,y,z,w> = PolynomialRing(ZZ, 4) 
     2203        sage: I = ideal(x*y-z^2, y^2-w^2)  #indirect doctest 
     2204        sage: macaulay2(I) # optional - macaulay2 
     2205        Ideal (x*y - z^2, y^2 - w^2) of Multivariate Polynomial Ring in x, y, z, w over Integer Ring 
    21992206        """ 
    22002207        if macaulay2 is None: macaulay2 = macaulay2_default 
    22012208        try: 
     
    22742281        R = self.ring() 
    22752282        return R(k) 
    22762283 
    2277 class NCPolynomialIdeal(MPolynomialIdeal_singular_base_repr, Ideal_generic): 
     2284class NCPolynomialIdeal(MPolynomialIdeal_singular_repr, Ideal_generic): 
    22782285    def __init__(self, ring, gens, coerce=True): 
     2286        r""" 
     2287        Computes a non-commutative ideal. 
     2288         
     2289        EXAMPLES:: 
     2290         
     2291            sage: A.<x,y,z> = FreeAlgebra(QQ, 3) 
     2292            sage: H = A.g_algebra({y*x:x*y-z, z*x:x*z+2*x, z*y:y*z-2*y}) 
     2293            sage: H.inject_variables() 
     2294            Defining x, y, z 
     2295 
     2296            sage: I = H.ideal([y^2, x^2, z^2-H.one_element()],coerce=False) # indirect doctest 
     2297        """ 
    22792298        Ideal_generic.__init__(self, ring, gens, coerce=coerce) 
    22802299 
    22812300    def __call_singular(self, cmd, arg = None): 
     2301        """ 
     2302        Internal function for calling a Singular function 
     2303 
     2304        INPUTS: 
     2305 
     2306        - ``cmd`` - string, representing a Singular function 
     2307 
     2308        - ``arg`` (Default: None) - arguments for which cmd is called 
     2309 
     2310        OUTPUTS: 
     2311 
     2312        - result of the Singular function call 
     2313 
     2314        EXAMPLES:: 
     2315 
     2316            sage: A.<x,y,z> = FreeAlgebra(QQ, 3) 
     2317            sage: H = A.g_algebra({y*x:x*y-z, z*x:x*z+2*x, z*y:y*z-2*y}) 
     2318            sage: H.inject_variables() 
     2319            Defining x, y, z 
     2320            sage: id = H.ideal(x + y, y + z) 
     2321            sage: id.std()  # indirect doctest 
     2322            Ideal (z, y, x) of Noncommutative Multivariate Polynomial Ring in x, y, z over Rational Field, nc-relations: {y*x: x*y - z, z*y: y*z - 2*y, z*x: x*z + 2*x} 
     2323        """ 
    22822324        from sage.libs.singular.function import singular_function 
    22832325        fun = singular_function(cmd) 
    22842326        if arg is None: 
     
    22902332        r""" 
    22912333        Computes a left GB of the ideal. 
    22922334         
    2293         EXAMPLE:: 
     2335        EXAMPLES:: 
    22942336         
    22952337            sage: A.<x,y,z> = FreeAlgebra(QQ, 3) 
    22962338            sage: H = A.g_algebra({y*x:x*y-z, z*x:x*z+2*x, z*y:y*z-2*y}) 
    22972339            sage: H.inject_variables() 
     2340            Defining x, y, z 
    22982341            sage: I = H.ideal([y^2, x^2, z^2-H.one_element()],coerce=False) 
    22992342            sage: I.std() 
    23002343            Ideal (z^2 - 1, y*z - y, x*z + x, y^2, 2*x*y - z - 1, x^2) of Noncommutative Multivariate Polynomial Ring in x, y, z over Rational Field... 
     
    23082351        r""" 
    23092352        Computes a two-sided GB of the ideal. 
    23102353         
    2311         EXAMPLE:: 
     2354        EXAMPLES:: 
    23122355         
    23132356            sage: A.<x,y,z> = FreeAlgebra(QQ, 3) 
    23142357            sage: H = A.g_algebra({y*x:x*y-z, z*x:x*z+2*x, z*y:y*z-2*y}) 
    23152358            sage: H.inject_variables() 
     2359            Defining x, y, z 
    23162360            sage: I = H.ideal([y^2, x^2, z^2-H.one_element()],coerce=False) 
    23172361            sage: I.twostd() 
    23182362            Ideal (z^2 - 1, y*z - y, x*z + x, y^2, 2*x*y - z - 1, x^2) of Noncommutative Multivariate Polynomial Ring in x, y, z over Rational Field... 
     
    23362380            sage: A.<x,y,z> = FreeAlgebra(QQ, 3) 
    23372381            sage: H = A.g_algebra({y*x:x*y-z, z*x:x*z+2*x, z*y:y*z-2*y}) 
    23382382            sage: H.inject_variables() 
     2383            Defining x, y, z 
    23392384            sage: I = H.ideal([y^2, x^2, z^2-H.one_element()],coerce=False) 
    2340             sage: G = vector(I.gens()); G 
    2341             ... 
     2385            sage: G = vector(I.gens()); G  
     2386            doctest:357: UserWarning: You are constructing a free module   over a noncommutative ring. Sage does 
     2387                         not have a concept of left/right and both sided modules be careful. It's also 
     2388                         not guarantied that all multiplications are done from the right side. 
     2389            doctest:573: UserWarning: You are constructing a free module over a noncommutative ring. Sage does not have a concept of left/right and both sided modules be careful. It's also not guarantied that all multiplications are done from the right side. 
    23422390            (y^2, x^2, z^2 - 1) 
    23432391            sage: M = I.syzygy_module(); M 
    2344             ... 
    2345             sage: (G.transpose() * M.transpose()).transpose() 
    2346             (0, 0) 
     2392            [                                                                         -z^2 - 8*z - 15                                                                                        0                                                                                      y^2] 
     2393            [                                                                                       0                                                                          -z^2 + 8*z - 15                                                                                      x^2] 
     2394            [                                                              x^2*z^2 + 8*x^2*z + 15*x^2                                                              -y^2*z^2 + 8*y^2*z - 15*y^2                                                                   -4*x*y*z + 2*z^2 + 2*z] 
     2395            [                 x^2*y*z^2 + 9*x^2*y*z - 6*x*z^3 + 20*x^2*y - 72*x*z^2 - 282*x*z - 360*x                                                              -y^3*z^2 + 7*y^3*z - 12*y^3                                                                                  6*y*z^2] 
     2396            [                                                              x^3*z^2 + 7*x^3*z + 12*x^3                 -x*y^2*z^2 + 9*x*y^2*z - 4*y*z^3 - 20*x*y^2 + 52*y*z^2 - 224*y*z + 320*y                                                                                 -6*x*z^2] 
     2397            [  x^2*y^2*z + 4*x^2*y^2 - 8*x*y*z^2 - 48*x*y*z + 12*z^3 - 64*x*y + 108*z^2 + 312*z + 288                                                                           -y^4*z + 4*y^4                                                                                        0] 
     2398            [                                                  2*x^3*y*z + 8*x^3*y + 9*x^2*z + 27*x^2                                   -2*x*y^3*z + 8*x*y^3 - 12*y^2*z^2 + 99*y^2*z - 195*y^2                                                                -36*x*y*z + 24*z^2 + 18*z] 
     2399            [                                                  2*x^3*y*z + 8*x^3*y + 9*x^2*z + 27*x^2                                   -2*x*y^3*z + 8*x*y^3 - 12*y^2*z^2 + 99*y^2*z - 195*y^2                                                                -36*x*y*z + 24*z^2 + 18*z] 
     2400            [                                                                           x^4*z + 4*x^4    -x^2*y^2*z + 4*x^2*y^2 - 4*x*y*z^2 + 32*x*y*z - 6*z^3 - 64*x*y + 66*z^2 - 240*z + 288                                                                                        0] 
     2401            [x^3*y^2*z + 4*x^3*y^2 + 18*x^2*y*z - 36*x*z^3 + 66*x^2*y - 432*x*z^2 - 1656*x*z - 2052*x                                      -x*y^4*z + 4*x*y^4 - 8*y^3*z^2 + 62*y^3*z - 114*y^3                                                                        48*y*z^2 - 36*y*z] 
     2402 
     2403            sage: M*G 
     2404            (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) 
    23472405         
    23482406        ALGORITHM: Uses Singular's syz command 
    23492407        """ 
     
    23562414        return matrix(self.ring(), S) 
    23572415 
    23582416 
    2359     def res(length): 
     2417    def res(self, length): 
     2418        r""" 
     2419        Computes the first syzygy (i.e., the module of relations of the 
     2420        given generators) of the ideal. 
     2421         
     2422        EXAMPLE:: 
     2423         
     2424            sage: A.<x,y,z> = FreeAlgebra(QQ, 3) 
     2425            sage: H = A.g_algebra({y*x:x*y-z, z*x:x*z+2*x, z*y:y*z-2*y}) 
     2426            sage: H.inject_variables() 
     2427            Defining x, y, z 
     2428            sage: I = H.ideal([y^2, x^2, z^2-H.one_element()],coerce=False) 
     2429            sage: I.res(3) 
     2430            <Resolution> 
     2431        """ 
    23602432        return self.__call_singular('res', length) 
    23612433 
    23622434 
    2363 class MPolynomialIdeal( MPolynomialIdeal_singular_commutative_repr, \ 
     2435class MPolynomialIdeal( MPolynomialIdeal_singular_repr, \ 
    23642436                        MPolynomialIdeal_macaulay2_repr, \ 
    23652437                        MPolynomialIdeal_magma_repr, \ 
    23662438                        Ideal_generic ): 
     
    29803052         
    29813053            sage: R.<x,y,z> = PolynomialRing(QQ) 
    29823054            sage: I = R.ideal(x^2-2*x*z+5, x*y^2+y*z+1, 3*y^2-8*x*z) 
    2983             sage: I.normal_basis() 
     3055            sage: I.normal_basis() #indirect doctest 
    29843056            [z^2, y*z, x*z, z, x*y, y, x, 1] 
    29853057        """ 
    29863058        from sage.rings.polynomial.multi_polynomial_ideal_libsingular import kbase_libsingular 
  • sage/rings/polynomial/multi_polynomial_libsingular.pyx

    diff -r 6a696ae732ab sage/rings/polynomial/multi_polynomial_libsingular.pyx
    a b  
    18801880        EXAMPLES:: 
    18811881 
    18821882            sage: P.<x,y,z>=PolynomialRing(QQ,3) 
    1883             sage: 3/2*x + 1/2*y + 1 
     1883            sage: 3/2*x + 1/2*y + 1 #indirect doctest 
    18841884            3/2*x + 1/2*y + 1 
    18851885 
    18861886        """ 
     
    18971897        EXAMPLES:: 
    18981898 
    18991899            sage: P.<x,y,z>=PolynomialRing(QQ,3) 
    1900             sage: 3/2*x - 1/2*y - 1 
     1900            sage: 3/2*x - 1/2*y - 1 #indirect doctest 
    19011901            3/2*x - 1/2*y - 1 
    19021902 
    19031903        """ 
     
    19161916        EXAMPLES:: 
    19171917 
    19181918            sage: P.<x,y,z>=PolynomialRing(QQ,3) 
    1919             sage: 3/2*x 
     1919            sage: 3/2*x # indirect doctest 
    19201920            3/2*x 
    19211921        """ 
    19221922 
     
    19281928        return new_MP((<MPolynomialRing_libsingular>self._parent),_p) 
    19291929         
    19301930    cpdef ModuleElement _lmul_(self, RingElement right): 
    1931         # all currently implemented rings are commutative 
    1932         return self._rmul_(right) 
     1931        """ 
     1932        Multiply left and right. 
     1933 
     1934        EXAMPLES:: 
     1935 
     1936            sage: P.<x,y,z>=PolynomialRing(QQ,3) 
     1937            sage: (3/2*x - 1/2*y - 1) * (3/2) # indirect doctest 
     1938            9/4*x - 3/4*y - 3/2 
     1939        """ 
     1940        # all currently implemented baser rings are commutative 
     1941        return right._rmul_(self) 
    19331942         
    19341943    cpdef RingElement  _mul_(left, RingElement right): 
    19351944        """ 
     
    19381947        EXAMPLES:: 
    19391948 
    19401949            sage: P.<x,y,z>=PolynomialRing(QQ,3) 
    1941             sage: (3/2*x - 1/2*y - 1) * (3/2*x + 1/2*y + 1) 
     1950            sage: (3/2*x - 1/2*y - 1) * (3/2*x + 1/2*y + 1) # indirect doctest 
    19421951            9/4*x^2 - 1/4*y^2 - y - 1 
    19431952 
    19441953            sage: P.<x,y> = PolynomialRing(QQ,order='lex') 
     
    19611970        EXAMPLES:: 
    19621971 
    19631972            sage: R.<x,y>=PolynomialRing(QQ,2) 
    1964             sage: f = (x + y)/3 
     1973            sage: f = (x + y)/3 # indirect doctest 
    19651974            sage: f.parent() 
    19661975            Multivariate Polynomial Ring in x, y over Rational Field 
    19671976 
     
    21372146 
    21382147            sage: P.<x,y,z> = QQ[] 
    21392148            sage: f = - 1*x^2*y - 25/27 * y^3 - z^2 
    2140             sage: latex(f) 
     2149            sage: latex(f)  # indirect doctest 
    21412150            - x^{2} y - \frac{25}{27} y^{3} - z^{2} 
    21422151        """ 
    21432152        cdef ring *_ring = (<MPolynomialRing_libsingular>self._parent)._ring 
     
    40964105        EXAMPLES:: 
    40974106 
    40984107            sage: R.<x,y> = PolynomialRing(GF(7), 2) 
    4099             sage: f = (x^3 + 2*y^2*x)^7; f 
     4108            sage: f = (x^3 + 2*y^2*x)^7; f          # indirect doctest 
    41004109            x^21 + 2*x^7*y^14 
    41014110 
    41024111            sage: h = macaulay2(f); h               # optional