Changeset 4041:95376008d175


Ignore:
Timestamp:
04/20/07 16:51:35 (6 years ago)
Author:
William Stein <wstein@…>
Branch:
default
Parents:
3932:2f9acd04105a (diff), 4040:11af6f84b0bc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge

Location:
sage
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • sage/misc/hg.py

    r3928 r4041  
    564564        self('%s --help | %s'%(cmd, pager())) 
    565565 
     566    def outgoing(self, url=None, opts=''): 
     567        """ 
     568        Use this to find changsets that are in your branch, but not in the 
     569        specified destination repository. If no destination is specified, the 
     570        official repository is used. 
     571 
     572        From the Mercurial documentation: 
     573            Show changesets not found in the specified destination repository or the 
     574            default push location. These are the changesets that would be pushed if 
     575            a push was requested. 
     576 
     577            See pull() for valid destination format details. 
     578 
     579        INPUT: 
     580            url:  default: self.url() -- the official repository 
     581                   * http://[user@]host[:port]/[path] 
     582                   * https://[user@]host[:port]/[path] 
     583                   * ssh://[user@]host[:port]/[path] 
     584                   * local directory (starting with a /) 
     585                   * name of a branch (for hg_sage); no /'s 
     586            options: (default: none) 
     587                 -M --no-merges     do not show merges 
     588                 -f --force         run even when remote repository is unrelated 
     589                 -p --patch         show patch 
     590                    --style         display using template map file 
     591                 -r --rev           a specific revision you would like to push 
     592                 -n --newest-first  show newest record first 
     593                    --template      display with template 
     594                 -e --ssh           specify ssh command to use 
     595                    --remotecmd     specify hg command to run on the remote side 
     596        """ 
     597        if url is None: 
     598            url = self.__url 
     599 
     600        if not '/' in url: 
     601            url = '%s/devel/sage-%s'%(SAGE_ROOT, url) 
     602 
     603        self('outgoing %s %s | %s' % (opts, url, pager())) 
     604 
    566605    def pull(self, url=None, options='-u'): 
    567606        """ 

  • sage/misc/hg.py

    r4013 r4041  
    179179             
    180180        print_open_msg(address, port) 
    181         tries = 0 
    182         while self('serve --address %s --port %s  %s'%(address, port, options)) != 2: 
    183             port += 1 
    184             tries += 1 
    185             if tries > 100: 
    186                 raise RuntimeError, "no port found after trying 100 (maybe your network is down)" 
    187             print_open_msg(address, port)             
    188          
     181        self('serve --address %s --port %s  %s'%(address, port, options)) 
     182        print_open_msg(address, port)             
    189183 
    190184    browse = serve 

  • sage/rings/arith.py

    r3926 r4041  
    6262 
    6363    This example involves a complex number. 
    64         sage: z = (1/2)*(1 + sqrt(3) *CC.0); z 
     64        sage: z = (1/2)*(1 + RDF(sqrt(3)) *CC.0); z 
    6565        0.500000000000000 + 0.866025403784439*I 
    6666        sage: p = algdep(z, 6); p 
    … …  
    14831483# primes at most a given limit. 
    14841484 
    1485 def factor(n, proof=True, int_=False, algorithm='pari', verbose=0): 
     1485def factor(n, proof=True, int_=False, algorithm='pari', verbose=0, **kwds): 
    14861486    """ 
    14871487    Returns the factorization of the integer n as a sorted list of 
    … …  
    15361536    if not isinstance(n, (int,long, integer.Integer)): 
    15371537        try: 
    1538             return n.factor() 
     1538            return n.factor(**kwds) 
    15391539        except AttributeError: 
    15401540            raise TypeError, "unable to factor n" 
    … …  
    22842284        [2, 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, 1, 1, 10, 1, 1, 12, 1, 1, 14, 1, 1, 16, 1, 1, 18, 1, 1, 20, 1, 1, 22, 1, 1, 24, 1, 1, 26, 1, 1, 28, 1, 1, 30, 1, 1, 32, 1, 1, 34, 1, 1, 36, 1, 1, 38, 1, 1] 
    22852285    """ 
     2286    import sage.calculus.calculus 
     2287    import sage.functions.constants 
     2288    # if x is a SymbolicExpression, try coercing it to a real number 
    22862289    if not bits is None: 
    2287         x = sage.rings.real_mpfr.RealField(bits)(x) 
     2290        try: 
     2291            x = sage.rings.real_mpfr.RealField(bits)(x) 
     2292        except  TypeError: 
     2293            raise TypeError, "can only find the continued fraction of a number" 
     2294    elif isinstance(x, float): 
     2295        from real_double import RDF 
     2296        x = RDF(x) 
     2297    elif isinstance(x, (sage.calculus.calculus.SymbolicExpression, 
     2298                        sage.functions.constants.Constant)): 
     2299        try: 
     2300            x = sage.rings.real_mpfr.RealField(53)(x) 
     2301        except TypeError: 
     2302            raise TypeError, "can only find the continued fraction of a number" 
    22882303    elif not partial_convergents and \ 
    22892304           isinstance(x, (integer.Integer, sage.rings.rational.Rational, 
    … …  
    26152630        0.652965496420167 + 0.343065839816545*I 
    26162631        sage: falling_factorial(1+I, 4) 
    2617         2.00000000000000 + 4.00000000000000*I 
     2632        (I - 2)*(I - 1)*I*(I + 1) 
     2633        sage: expand(falling_factorial(1+I, 4)) 
     2634        4*I + 2 
    26182635        sage: falling_factorial(I, 4) 
    2619         -10.0000000000000 
     2636        (I - 3)*(I - 2)*(I - 1)*I 
    26202637 
    26212638        sage: M = MatrixSpace(ZZ, 4, 4) 
    … …  
    26762693        0.266816390637832 + 0.122783354006372*I 
    26772694     
    2678         sage: rising_factorial(I, 4) 
    2679         -10.0000000000000 
     2695        sage: a = rising_factorial(I, 4); a 
     2696        I*(I + 1)*(I + 2)*(I + 3) 
     2697        sage: expand(a) 
     2698        -10 
    26802699     
    26812700    See falling_factorial(I, 4). 
    26822701     
    2683         sage: R = ZZ['x'] 
     2702        sage: x = polygen(ZZ) 
    26842703        sage: rising_factorial(x, 4) 
    26852704        x^4 + 6*x^3 + 11*x^2 + 6*x  

  • sage/rings/arith.py

    r4037 r4041  
    18741874        -1 
    18751875 
    1876     IMPLEMENTATION: Using Pari. 
     1876    IMPLEMENTATION: Using GMP. 
    18771877    """ 
    18781878    x = integer_ring.ZZ(x) 
    1879     y = integer_ring.ZZ(y)     
    1880     return integer_ring.ZZ(pari(x).kronecker(y).python()) 
     1879    return integer_ring.ZZ(x.kronecker(y)) 
    18811880 
    18821881def kronecker(x,y): 

  • sage/rings/integer.pyx

    r3927 r4041  
    676676            RuntimeError: exponent must be at most 4294967294  # 32-bit 
    677677            RuntimeError: exponent must be at most 18446744073709551614 # 64-bit 
     678 
     679        We raise 2 to various interesting exponents: 
     680            sage: 2^x                # symbolic x 
     681            2^x 
     682            sage: 2^1.5              # real number 
     683            2.82842712474619  
     684            sage: 2^I                # complex number 
     685            2^I 
     686            sage: sage: f = 2^(sin(x)-cos(x)); f 
     687            2^(sin(x) - cos(x)) 
     688            sage: f(3) 
     689            2^(sin(3) - cos(3)) 
     690            sage: 2^(x+y+z) 
     691            2^(z + y + x) 
     692            sage: 2^(1/2) 
     693            sqrt(2) 
     694            sage: 2^(-1/2) 
     695            1/sqrt(2) 
    678696        """ 
    679697        cdef Integer _n 
    … …  
    690708            _n = Integer(n) 
    691709        except TypeError: 
    692             raise TypeError, "exponent (=%s) must be an integer.\nCoerce your numbers to real or complex numbers first."%n 
     710            try: 
     711                s = n.parent()(self) 
     712                return s**n 
     713            except AttributeError: 
     714                raise TypeError, "exponent (=%s) must be an integer.\nCoerce your numbers to real or complex numbers first."%n 
    693715 
    694716        if _n < 0: 
    … …  
    806828 
    807829           sage: x = 3^100000 
    808            sage: log(RR(x), 3) 
     830           sage: RR(log(RR(x), 3)) 
    809831           100000.000000000 
    810            sage: log(RR(x + 100000), 3) 
     832           sage: RR(log(RR(x + 100000), 3)) 
    811833           100000.000000000 
    812834 
    … …  
    16291651 
    16301652     
    1631     def sqrt(self, bits=None): 
     1653    def sqrt_approx(self, bits=None): 
    16321654        r""" 
    16331655        Returns the positive square root of self, possibly as a 
    … …  
    16391661                    If bits is not specified, the number of 
    16401662                    bits of precision is at least twice the 
    1641                     number of bits of self (the precision 
    1642                     is always at least 53 bits if not specified). 
     1663                    number of bits of self. 
    16431664        OUTPUT: 
    16441665            integer, real number, or complex number. 
    … …  
    16491670        EXAMPLE: 
    16501671            sage: Z = IntegerRing() 
    1651             sage: Z(4).sqrt() 
    1652             2 
    1653             sage: Z(4).sqrt(53) 
     1672            sage: Z(4).sqrt_approx(53) 
    16541673            2.00000000000000 
    1655             sage: Z(2).sqrt(53) 
     1674            sage: Z(2).sqrt_approx(53) 
    16561675            1.41421356237310 
    1657             sage: Z(2).sqrt(100) 
     1676            sage: Z(2).sqrt_approx(100) 
    16581677            1.4142135623730950488016887242 
    1659             sage: n = 39188072418583779289; n.square_root() 
     1678            sage: n = 39188072418583779289; n.sqrt() 
    16601679            6260037733 
    1661             sage: (100^100).sqrt() 
     1680            sage: (100^100).sqrt_approx() 
    16621681            10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 
     1682            sage: (-1).sqrt_approx() 
     1683            1.00000000000000*I 
    16631684            sage: (-1).sqrt() 
    1664             1.00000000000000*I 
     1685            I 
    16651686            sage: sqrt(-2) 
    1666             1.41421356237310*I 
     1687            sqrt(2)*I 
     1688            sage: sqrt(-2.0) 
     1689            sqrt(2)*I 
    16671690            sage: sqrt(97) 
    1668             9.84885780179610 
    1669             sage: n = 97; n.sqrt(200) 
     1691            sqrt(97) 
     1692            sage: n = 97; n.sqrt_approx(200) 
    16701693            9.8488578017961047217462114149176244816961362874427641717232 
    16711694        """ 
    16721695        if bits is None: 
    1673             try: 
    1674                 return self.square_root() 
    1675             except ValueError: 
    1676                 pass 
    16771696            bits = max(53, 2*(mpz_sizeinbase(self.value, 2)+2)) 
    16781697             
    … …  
    16861705            return R(self).sqrt() 
    16871706 
    1688     def square_root(self): 
     1707    def sqrt(self): 
    16891708        """ 
    16901709        Return the positive integer square root of self, or raises a ValueError 
    … …  
    16921711 
    16931712        EXAMPLES: 
    1694             sage: Integer(144).square_root() 
     1713            sage: Integer(144).sqrt() 
    16951714            12 
    1696             sage: Integer(102).square_root() 
    1697             Traceback (most recent call last): 
    1698             ... 
    1699             ValueError: self (=102) is not a perfect square 
     1715            sage: Integer(102).sqrt() 
     1716            sqrt(102) 
    17001717        """ 
    17011718        n = self.isqrt() 
    17021719        if n * n == self: 
    17031720            return n 
    1704         raise ValueError, "self (=%s) is not a perfect square"%self 
     1721        from sage.calculus.calculus import sqrt 
     1722        return sqrt(self) 
     1723        #raise ValueError, "self (=%s) is not a perfect square"%self 
    17051724             
    17061725 

  • sage/rings/integer.pyx

    r4033 r4041  
    1313    -- Rishikesh (2007-02-25): changed quo_rem so that the rem is positive 
    1414    -- David Harvey, Martin Albrecht, Robert Bradshaw (2007-03-01): optimized Integer constructor and pool 
     15    -- Robert Bradshaw (2007-04-12): is_perfect_power, Jacobi symbol (with Kronecker extension) 
     16                                     Convert some methods to use GMP directly rather than pari, Integer() -> PY_NEW(Integer) 
    1517 
    1618EXAMPLES: 
    … …  
    297299    def _xor(Integer self, Integer other): 
    298300        cdef Integer x 
    299         x = Integer() 
     301        x = PY_NEW(Integer) 
    300302        mpz_xor(x.value, self.value, other.value) 
    301303        return x 
    … …  
    337339        """ 
    338340        cdef Integer z 
    339         z = Integer() 
     341        z = PY_NEW(Integer) 
    340342        set_mpz(z,self.value) 
    341343        return z 
    … …  
    616618    def __floordiv(Integer self, Integer other): 
    617619        cdef Integer x 
    618         x = Integer() 
    619          
    620  
     620        x = PY_NEW(Integer) 
     621         
    621622        _sig_on 
    622623        mpz_fdiv_q(x.value, self.value, other.value) 
    … …  
    784785        cdef Integer x 
    785786        cdef int is_exact 
    786         x = Integer() 
     787        x = PY_NEW(Integer) 
    787788        _sig_on 
    788789        is_exact = mpz_root(x.value, self.value, n) 
    … …  
    895896        """ 
    896897        cdef Integer x 
    897         x = Integer() 
     898        x = PY_NEW(Integer) 
    898899        mpz_abs(x.value, self.value) 
    899900        return x 
    … …  
    919920         
    920921        cdef Integer x 
    921         x = Integer() 
     922        x = PY_NEW(Integer) 
    922923 
    923924        _sig_on 
    … …  
    958959 
    959960        cdef Integer q, r 
    960         q = Integer() 
    961         r = Integer() 
     961        q = PY_NEW(Integer) 
     962        r = PY_NEW(Integer) 
    962963 
    963964        _sig_on 
    … …  
    998999 
    9991000        cdef Integer q, r 
    1000         q = Integer() 
    1001         r = Integer() 
     1001        q = PY_NEW(Integer) 
     1002        r = PY_NEW(Integer) 
    10021003 
    10031004        _sig_on 
    … …  
    10321033            raise ZeroDivisionError, "cannot raise to a power modulo 0" 
    10331034         
    1034         x = Integer() 
     1035        x = PY_NEW(Integer) 
    10351036 
    10361037        _sig_on 
    … …  
    10741075        cdef Integer x, _mod 
    10751076        _mod = Integer(mod) 
    1076         x = Integer() 
     1077        x = PY_NEW(Integer) 
    10771078 
    10781079        _sig_on 
    … …  
    12321233         
    12331234        cdef Integer z 
    1234         z = Integer() 
     1235        z = PY_NEW(Integer) 
    12351236        mpz_set(z.value,x) 
    12361237        mpz_clear(x) 
    … …  
    13001301        _sig_off 
    13011302 
    1302         z = Integer() 
     1303        z = PY_NEW(Integer) 
    13031304        set_mpz(z, x) 
    13041305        mpz_clear(x) 
    … …  
    13761377            False 
    13771378        """ 
    1378         return bool(self._pari_().issquare()) 
     1379        return bool(mpz_perfect_square_p(self.value)) 
    13791380 
    13801381    def is_prime(self): 
    … …  
    14051406        """ 
    14061407        return bool(self._pari_().ispseudoprime()) 
    1407  
     1408         
     1409    def is_perfect_power(self): 
     1410        r""" 
     1411        Retuns \code{True} if self is a perfect power. 
     1412 
     1413        EXAMPLES: 
     1414            sage: z = 8 
     1415            sage: z.is_perfect_power() 
     1416            True 
     1417            sage: z = 144 
     1418            sage: z.is_perfect_power() 
     1419            True 
     1420            sage: z = 10 
     1421            sage: z.is_perfect_power() 
     1422            False 
     1423        """ 
     1424        return bool(mpz_perfect_power_p(self.value)) 
     1425         
     1426    def jacobi(self, b): 
     1427        """ 
     1428        Calculate the Jacobi symbol $\left(\frac{self,b}\right)$. 
     1429 
     1430        EXAMPLES: 
     1431            sage: z = -1 
     1432            sage: z.jacobi(17) 
     1433            1 
     1434            sage: z.jacobi(19) 
     1435            -1 
     1436            sage: z.jacobi(17*19) 
     1437            -1 
     1438            sage: (2).jacobi(17) 
     1439            1 
     1440            sage: (3).jacobi(19) 
     1441            -1 
     1442            sage: (6).jacobi(17*19) 
     1443            -1 
     1444            sage: (6).jacobi(33) 
     1445            0 
     1446            sage: a = 3; b = 7 
     1447            sage: a.jacobi(b) == -b.jacobi(a) 
     1448            True 
     1449        """ 
     1450        cdef long tmp 
     1451        if PY_TYPE_CHECK(b, int): 
     1452            tmp = b 
     1453            if (tmp & 1) == 0: 
     1454                raise ValueError, "Jacobi symbol not defined for even b." 
     1455            return mpz_kronecker_si(self.value, tmp) 
     1456        if not PY_TYPE_CHECK(b, Integer): 
     1457            b = Integer(b) 
     1458        if mpz_even_p((<Integer>b).value): 
     1459            raise ValueError, "Jacobi symbol not defined for even b." 
     1460        return mpz_jacobi(self.value, (<Integer>b).value) 
     1461         
     1462    def kronecker(self, b): 
     1463        """ 
     1464        Calculate the Jacobi symbol $\left(\frac{self,b}\right)$ with the Kronecker extension  
     1465        $(self/2)=(2/self)$ when self odd, or $(self/2)=0$ when $self$ even. 
     1466 
     1467        EXAMPLES: 
     1468        EXAMPLES: 
     1469            sage: z = 5 
     1470            sage: z.kronecker(41) 
     1471            1 
     1472            sage: z.kronecker(43) 
     1473            -1 
     1474            sage: z.kronecker(8) 
     1475            -1 
     1476            sage: z.kronecker(15) 
     1477            0 
     1478            sage: a = 2; b = 5 
     1479            sage: a.kronecker(b) == b.kronecker(a) 
     1480            True 
     1481        """ 
     1482        if PY_TYPE_CHECK(b, int): 
     1483            return mpz_kronecker_si(self.value, b) 
     1484        if not PY_TYPE_CHECK(b, Integer): 
     1485            b = Integer(b) 
     1486        return mpz_kronecker(self.value, (<Integer>b).value) 
     1487         
    14081488    def square_free_part(self): 
    14091489        """ 
    … …  
    15621642            raise ValueError, "square root of negative number not defined." 
    15631643        cdef Integer x 
    1564         x = Integer() 
     1644        x = PY_NEW(Integer) 
    15651645 
    15661646        _sig_on 
    … …  
    16701750        _sig_off 
    16711751         
    1672         g0 = Integer() 
    1673         s0 = Integer() 
    1674         t0 = Integer() 
     1752        g0 = PY_NEW(Integer) 
     1753        s0 = PY_NEW(Integer) 
     1754        t0 = PY_NEW(Integer) 
    16751755        set_mpz(g0,g) 
    16761756        set_mpz(s0,s) 
    … …  
    17651845    cdef _and(Integer self, Integer other): 
    17661846        cdef Integer x 
    1767         x = Integer() 
     1847        x = PY_NEW(Integer) 
    17681848        mpz_and(x.value, self.value, other.value) 
    17691849        return x 
    … …  
    17771857    cdef _or(Integer self, Integer other): 
    17781858        cdef Integer x 
    1779         x = Integer() 
     1859        x = PY_NEW(Integer) 
    17801860        mpz_ior(x.value, self.value, other.value) 
    17811861        return x 
    … …  
    18571937        if r == 0: 
    18581938            raise ZeroDivisionError, "Inverse does not exist." 
    1859         ans = Integer() 
     1939        ans = PY_NEW(Integer) 
    18601940        set_mpz(ans,x) 
    18611941        mpz_clear(x) 
    … …  
    18891969        _sig_off 
    18901970 
    1891         g0 = Integer() 
     1971        g0 = PY_NEW(Integer) 
    18921972        set_mpz(g0,g) 
    18931973        mpz_clear(g) 
    … …  
    19622042         
    19632043     
    1964     w = Integer() 
     2044    w = PY_NEW(Integer) 
    19652045    mpz_set(w.value, z) 
    19662046    mpz_clear(z) 
    … …  
    20052085 
    20062086     
    2007     w = Integer() 
     2087    w = PY_NEW(Integer) 
    20082088    mpz_set(w.value, z) 
    20092089    mpz_clear(z) 

  • sage/rings/polynomial_element.pyx

    r3925 r4041  
    55    -- William Stein: first version 
    66    -- Martin Albrecht: Added singular coercion. 
     7 
     8TESTS: 
     9     sage: R.<x> = ZZ[] 
     10     sage: f = x^5 + 2*x^2 + (-1) 
     11     sage: f == loads(dumps(f)) 
     12     True 
     13 
    714""" 
    815 
    … …  
    518525        r""" 
    519526        EXAMPLES: 
     527                        sage: x = polygen(QQ) 
    520528            sage: f = x^3+2/3*x^2 - 5/3 
    521529            sage: f._repr_() 
    … …  
    530538        r""" 
    531539        EXAMPLES: 
     540                        sage: x = polygen(QQ) 
    532541            sage: latex(x^3+2/3*x^2 - 5/3) 
    533542             x^{3} + \frac{2}{3}x^{2} - \frac{5}{3} 
    … …  
    939948             
    940949        Notice that the unit factor is included when we multiply $F$ back out. 
    941             sage: F.mul() 
     950            sage: expand(F) 
    942951            2*x^10 + 2*x + 2*a 
    943952 
    … …  
    974983            sage: F = factor(x^2-3); F 
    975984            (1.0000000000000000000000000000*x + 1.7320508075688772935274463415) * (1.0000000000000000000000000000*x - 1.7320508075688772935274463415) 
    976             sage: F.mul() 
     985            sage: expand(F) 
    977986            1.0000000000000000000000000000*x^2 - 3.0000000000000000000000000000 
    978987            sage: factor(x^2 + 1) 
    … …  
    982991            sage: F = factor(x^2+3); F 
    983992            (1.0000000000000000000000000000*x + -1.7320508075688772935274463415*I) * (1.0000000000000000000000000000*x + 1.7320508075688772935274463415*I) 
    984             sage: F.mul() 
     993            sage: expand(F) 
    985994            1.0000000000000000000000000000*x^2 + 3.0000000000000000000000000000 
    986995            sage: factor(x^2+1) 
    … …  
    988997            sage: f = C.0 * (x^2 + 1) ; f 
    989998            1.0000000000000000000000000000*I*x^2 + 1.0000000000000000000000000000*I 
    990             sage: F=factor(f); F 
     999            sage: F = factor(f); F 
    9911000            (1.0000000000000000000000000000*I) * (1.0000000000000000000000000000*x + -1.0000000000000000000000000000*I) * (1.0000000000000000000000000000*x + 1.0000000000000000000000000000*I) 
    992             sage: F.mul() 
     1001            sage: expand(F) 
    9931002            1.0000000000000000000000000000*I*x^2 + 1.0000000000000000000000000000*I 
    9941003        """ 

  • sage/rings/polynomial_element.pyx

    r4037 r4041  
    149149        return self * self.parent()(right)  
    150150         
    151     def __call__(self, *a): 
     151    def __call__(self, *x): 
    152152        """ 
    153153        Evaluate polynomial at x=a using Horner's rule 
    … …  
    199199            Full MatrixSpace of 2 by 2 dense matrices over Rational Field 
    200200             
    201  
     201        Nested polynomial ring elements can be called like multi-variate polynomials. 
     202            sage: R.<x> = QQ[] 
     203            sage: S.<y> = R[] 
     204            sage: f = x+y*x+y^2 
     205            sage: f.parent() 
     206            Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field 
     207            sage: f(2) 
     208            3*x + 4 
     209            sage: f(2,4) 
     210            16 
     211            sage: R.<t> = PowerSeriesRing(QQ, 't'); S.<x> = R[] 
     212            sage: f = 1 + x*t^2 + 3*x*t^4 
     213            sage: f(2) 
     214            1 + 2*t^2 + 6*t^4 
     215            sage: f(2, 1/2) 
     216            15/8 
     217             
    202218        AUTHORS: 
    203219            -- David Joyner, 2005-04-10 
    … …  
    205221               is determined by the arithmetic 
    206222            -- William Stein, 2007-03-24: fix parent being determined in the constant case! 
    207         """ 
    208         a = a[0] 
    209         if isinstance(a, tuple): 
    210             a = a[0] 
     223            -- Robert Bradshaw, 2007-04-09: add support for nested calling 
     224        """ 
     225        if isinstance(x[0], tuple): 
     226            x = x[0] 
     227        a = x[0] 
     228 
    211229        d = self.degree() 
    212230        result = self[d] 
     231        if len(x) > 1: 
     232            other_args = x[1:] 
     233            if hasattr(result, '__call__'): 
     234                result = result(other_args) 
     235            else: 
     236                raise TypeError, "Wrong number of arguments" 
     237                 
    213238        if d == 0: 
    214239            try: 
    … …  
    216241            except AttributeError: 
    217242                return result 
     243 
    218244        i = d - 1 
    219         while i >= 0: 
    220             result = result * a + self[i] 
    221             i -= 1 
     245        if len(x) > 1: 
     246            while i >= 0: 
     247                result = result * a + self[i](other_args) 
     248                i -= 1 
     249        else: 
     250            while i >= 0: 
     251                result = result * a + self[i] 
     252                i -= 1 
    222253        return result 
    223254 

  • sage/rings/power_series_ring_element.py

    r4003 r4041  
    11841184        return self.__f 
    11851185 
    1186     def __call__(self, x): 
     1186    def __call__(self, *xs): 
    11871187        """ 
    11881188        EXAMPLE: 
    … …  
    11921192            2         
    11931193        """ 
     1194        if isinstance(xs[0], tuple): 
     1195            xs = xs[0] 
     1196        x = xs[0] 
    11941197        try: 
    11951198            if x.parent() is self.parent(): 
    11961199                if not (self.prec() is infinity): 
    11971200                    x = x.add_bigoh(self.prec()*x.valuation()) 
     1201                    xs = list(xs); xs[0] = x; xs = tuple(xs) # tuples are immutable 
    11981202        except AttributeError: 
    11991203            pass 
    1200         return self.__f(x) 
     1204        return self.__f(xs) 
    12011205 
    12021206    def __setitem__(self, n, value): 

  • sage/rings/real_double.pyx

    r3927 r4041  
    4040import sage.rings.integer 
    4141import sage.rings.rational 
     42 
     43from sage.rings.integer cimport Integer 
     44 
     45def is_RealDoubleField(x): 
     46    return bool(PY_TYPE_CHECK(x, RealDoubleField_class)) 
    4247 
    4348cdef class RealDoubleField_class(Field): 
    … …  
    112117            True 
    113118        """ 
     119        if hasattr(x, '_real_double_'): 
     120            return x._real_double_(self) 
    114121        return RealDoubleElement(x) 
    115122 
    … …  
    659666        return long(self._value) 
    660667 
    661     def _complex_number_(self): 
    662         return sage.rings.complex_field.ComplexField()(self) 
    663  
    664     def _complex_double_(self): 
    665         return sage.rings.complex_double.ComplexDoubleField()(self) 
     668    def _complex_mpfr_field_(self, CC): 
     669        """ 
     670        EXAMPLES: 
     671            sage: a = RDF(1/3) 
     672            sage: CC(a) 
     673            0.333333333333333 
     674            sage: a._complex_mpfr_field_(CC) 
     675            0.333333333333333 
     676 
     677        If we coerce to a higher-precision field the extra bits appear 
     678        random; they are actualy 0's in base 2. 
     679            sage: a._complex_mpfr_field_(ComplexField(100)) 
     680            0.33333333333333331482961625625 
     681            sage: a._complex_mpfr_field_(ComplexField(100)).str(2) 
     682            '0.01010101010101010101010101010101010101010101010101010100000000000000000000000000000000000000000000000' 
     683        """ 
     684        return CC(self._value) 
     685 
     686    def _complex_double_(self, CDF): 
     687        """ 
     688        EXAMPLES: 
     689            sage: CDF(RDF(1/3)) 
     690            0.333333333333 
     691        """ 
     692        return CDF(self._value) 
    666693 
    667694    def _pari_(self): 
    … …  
    729756        if self._value >= 0: 
    730757            return self.square_root() 
    731         return self._complex_double_().sqrt() 
     758        return self._complex_double_(sage.rings.complex_double.CDF).sqrt() 
    732759         
    733760 
    … …  
    818845            sage: a^a 
    819846            1.29711148178 
     847 
     848        Symbolic examples: 
     849            sage: RDF('-2.3')^(x+y^3+sin(x)) 
     850            -2.30000000000000^(y^3 + sin(x) + x) 
     851            sage: RDF('-2.3')^x 
     852            -2.30000000000000^x 
    820853        """ 
    821854        cdef RealDoubleElement x 
    822         if PY_TYPE_CHECK(self, RealDoubleElement): 
     855        if PY_TYPE_CHECK(exponent, RealDoubleElement): 
    823856            return self.__pow(RealDoubleElement(exponent)) 
    824857        elif PY_TYPE_CHECK(exponent, int): 
    … …  
    826859        elif PY_TYPE_CHECK(exponent, Integer) and exponent < INT_MAX: 
    827860            return self.__pow_int(int(exponent)) 
    828         elif not isinstance(exponent, RealDoubleElement): 
    829             x = RealDoubleElement(exponent) 
    830         else: 
    831             x = exponent 
     861        try: 
     862            x = self.parent()(exponent) 
     863        except TypeError: 
     864            try: 
     865                return exponent.parent()(self)**exponent 
     866            except AttributeError: 
     867                raise TypeError 
    832868        return self.__pow(x) 
    833869 
    … …  
    900936            sage: r = RDF('16.0'); r.log10() 
    901937            1.20411998266 
    902             sage: r.log() / log(10) 
     938            sage: r.log() / RDF(log(10)) 
    903939            1.20411998266 
    904940            sage: r = RDF('39.9'); r.log10() 
    … …  
    917953            sage: r = RDF(16); r.logpi() 
    918954            2.42204624559 
    919             sage: r.log() / log(pi) 
     955            sage: r.log() / RDF(log(pi)) 
    920956            2.42204624559 
    921957            sage: r = RDF('39.9'); r.logpi() 

  • sage/rings/real_double.pyx

    r4036 r4041  
    2222include '../ext/cdefs.pxi' 
    2323include '../ext/stdsage.pxi' 
     24include '../ext/random.pxi' 
    2425include '../ext/interrupt.pxi' 
    2526include '../gsl/gsl.pxi' 
    … …  
    3132cimport sage.libs.pari.gen 
    3233import sage.libs.pari.gen 
    33  
    34 from random import random 
    3534 
    3635from sage.misc.sage_eval import sage_eval 
    … …  
    207206        return x 
    208207 
    209     def random_element(self, float min=-1, float max=1): 
     208    def random_element(self, double min=-1, double max=1): 
    210209        """ 
    211210        Return a random element of this real double field in the interval [min, max]. 
    … …  
    217216            106.592535785 
    218217        """ 
    219         return self._new_c((max-min)*random() + min) 
     218        return self._new_c((max-min)*(<double>random())/RAND_MAX + min) 
    220219     
    221220    def name(self): 

  • sage/rings/real_mpfr.pyx

    r3927 r4041  
    247247        elif self.__prec <= 53 and is_RealDoubleElement(x): 
    248248            return self(x) 
    249         import sage.functions.constants 
    250         return self._coerce_try(x, [sage.functions.constants.ConstantRing]) 
     249        raise TypeError 
     250        #import sage.functions.constants 
     251        #return self._coerce_try(x, [sage.functions.constants.ConstantRing]) 
    251252 
    252253    def __cmp__(self, other): 
    … …  
    17671768            1.0000000*I                    # 32-bit 
    17681769            -1.0842022e-19 + 1.0000000*I   # 64-bit 
     1770 
     1771        We raise a real number to a symbolic object: 
     1772            sage: 1.5^x 
     1773            1.50000000000000^x 
     1774            sage: -2.3^(x+y^3+sin(x)) 
     1775            -2.30000000000000^(y^3 + sin(x) + x) 
    17691776        """ 
    17701777        cdef RealNumber x 
    … …  
    17721779            return self.__pow__(float(exponent)) 
    17731780        if not PY_TYPE_CHECK(exponent, RealNumber): 
    1774             x = self 
    1775             exponent = x._parent(exponent) 
     1781            try: 
     1782                x = self 
     1783                exponent = x._parent(exponent) 
     1784            except TypeError: 
     1785                try: 
     1786                    return exponent.parent()(self)**exponent 
     1787                except AttributeError: 
     1788                    raise TypeError 
    17761789        return self.__pow(exponent) 
    17771790 
    … …  
    22682281 
    22692282        EXAMPLE: 
    2270              sage: r = sqrt(2); r 
     2283             sage: r = sqrt(2.0); r 
    22712284             1.41421356237310 
    22722285             sage: r.algdep(5) 
    … …  
    22852298 
    22862299         EXAMPLE: 
    2287               sage: r = sqrt(2); r 
     2300              sage: r = sqrt(2.0); r 
    22882301              1.41421356237310 
    22892302              sage: r.algdep(5) 
    … …  
    23852398 
    23862399def is_RealField(x): 
    2387     return PY_TYPE_CHECK(x, RealField) 
     2400    return bool(PY_TYPE_CHECK(x, RealField)) 
    23882401 
    23892402def is_RealNumber(x): 
    2390     return PY_TYPE_CHECK(x, RealNumber) 
     2403    return bool(PY_TYPE_CHECK(x, RealNumber)) 
    23912404 
    23922405def __create__RealField_version0(prec, sci_not, rnd): 

  • sage/rings/real_mpfr.pyx

    r4034 r4041  
    4848include '../ext/interrupt.pxi' 
    4949include "../ext/stdsage.pxi" 
     50include "../ext/random.pxi" 
    5051 
    5152cimport sage.rings.ring 
    … …  
    412413            0.69314718055994530941723212146 
    413414        """ 
    414         cdef RealNumber x 
    415         x = self._new()         
     415        cdef RealNumber x = self._new() 
    416416        mpfr_const_log2(x.value, self.rnd) 
    417417        return x 
     418         
     419    def random_element(self, min=-1, max=1, distribution=None): 
     420        """ 
     421        Returns a uniformly distributed random number between  
     422        min and max (default -1 to 1).  
     423         
     424        EXAMPLES: 
     425            sage: RealField(100).random_element(-5, 10) 
     426            4.2682457657074627882421620493 
     427            sage: RealField(10).random_element() 
     428            .27 
     429        """ 
     430        cdef RealNumber x = self._new() 
     431        mpfr_urandomb(x.value, state) 
     432        if min == 0 and max == 1: 
     433            return x 
     434        else: 
     435            return (max-min)*x + min 
    418436 
    419437    def factorial(self, int n): 
Note: See TracChangeset for help on using the changeset viewer.