U 9%e@s"ddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZmZm Z mZmZmZddlmZmZddlmZdd lmZmZdd lmZdd lmZmZdd l m!Z!dd l"m#Z#ddl$m%Z%ddl&m'Z'm(Z(m)Z)ddl*m+Z+ddl,Z,ddl-m.Z/ddl-m0Z0m1Z2ddl3m4Z4ddl-m5Z5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mZ?m@ZAmBZBmCZDmEZEmFZFddlGmHZHmIZImJZJddlKmLZLeMdZNdxddZOddZPddiZQdydd ZRd!d"ZSd#d$ZTeUd%ZVd&d'ZWe d(d)d*ZXejYZZd+d,Z[d-d.Z\d/d0Z]d1d2Z^Gd3d4d4eZ_Gd5d6d6e_Z`e`eea<eejb<e`ZcGd7d8d8e_ZdGd9d:d:edZeeeeef<Gd;d<dd>edZhGd?d@d@eeZiGdAdBdBeiedCZjGdDdEdEeiedCZkGdFdGdGeiedCZlGdHdIdIehedCZmGdJdKdKe_edCZnejnZoGdLdMdMe_edCZpGdNdOdOe_edCZqejqZre+eqedPdQZsGdRdSdSeedCZtejtZuGdTdUdUeZvGdVdWdWevedCZwejwZxGdXdYdYevedCZyejyZzGdZd[d[evedCZ{Gd\d]d]evedCZ|Gd^d_d_evedCZ}Gd`dadaevedCZ~GdbdcdceedCZejZdddeZe+e e_dfdQZsdgdhZeeej<e(rdidjZdkdlZeeee)d<eeee)dd<dmdnZeeee,jdd<dodpZeee:<dqdrZeee<ddslmZmZddtlmZeke_ddulmZeje_dvdwZeejqejnejpejtfZdS)z) annotationsN) lru_cache)Tuple) SympifyError_sympy_convertersympify_convert_numpy_types_sympify_is_numpy_instance)S Singleton)Basic)Expr AtomicExpr) pure_complex)cacheit clear_cache) _sympifyit) fuzzy_not) NumberKind) SYMPY_INTSHAS_GMPYgmpy)dispatch)bitcount round_nearestMPZ)mpf_powmpf_pimpf_e phi_fixed) mpnumeric)finffninffnanfzero _normalize prec_to_dps dps_to_prec)as_intdebug filldedent)global_parametersc Cst|tr*t|ddstdt||kS|s8||}}|s@dS|s||}}|dkrht|t|kS|dkrt|t|}}tdd||fDstd|t}|t}|s|s||kStd D]^}t|dd}|s|r| t t d d |D}t|dd}q.q||}}||}}qt|} | sj|rj| t t d d |D}t|dd} |r| r|d s| d rtddt || DSdt t |j t|d|j }tt|||dkSt||} t|} |r| d kr| | |kS| |kSdS)aReturn a bool indicating whether the error between z1 and z2 is $\le$ ``tol``. Examples ======== If ``tol`` is ``None`` then ``True`` will be returned if :math:`|z1 - z2|\times 10^p \le 5` where $p$ is minimum value of the decimal precision of each value. >>> from sympy import comp, pi >>> pi4 = pi.n(4); pi4 3.142 >>> comp(_, 3.142) True >>> comp(pi4, 3.141) False >>> comp(pi4, 3.143) False A comparison of strings will be made if ``z1`` is a Number and ``z2`` is a string or ``tol`` is ''. >>> comp(pi4, 3.1415) True >>> comp(pi4, 3.1415, '') False When ``tol`` is provided and $z2$ is non-zero and :math:`|z1| > 1` the error is normalized by :math:`|z1|`: >>> abs(pi4 - 3.14)/pi4 0.000509791731426756 >>> comp(pi4, 3.14, .001) # difference less than 0.1% True >>> comp(pi4, 3.14, .0005) # difference less than 0.1% False When :math:`|z1| \le 1` the absolute error is used: >>> 1/pi4 0.3183 >>> abs(1/pi4 - 0.3183)/(1/pi4) 3.07371499106316e-5 >>> abs(1/pi4 - 0.3183) 9.78393554684764e-6 >>> comp(1/pi4, 0.3183, 1e-5) True To see if the absolute error between ``z1`` and ``z2`` is less than or equal to ``tol``, call this as ``comp(z1 - z2, 0, tol)`` or ``comp(z1 - z2, tol=tol)``: >>> abs(pi4 - 3.14) 0.00160156249999988 >>> comp(pi4 - 3.14, 0, .002) True >>> comp(pi4 - 3.14, 0, .001) False T)Zor_realz$when z2 is a str z1 must be a NumberNcss|] }|jVqdSN) is_number.0ir6Q/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/core/numbers.py sszcomp..zexpecting 2 numbersr/cSsg|] }|jqSr6_precr3r6r6r7 szcomp..cSsg|] }|jqSr6r9r3r6r6r7r;srcss|]\}}t||VqdSr1)comp)r4r5jr6r6r7r8s r:) isinstancestrr ValueErrorrallZatomsFloatrangenr)minzipr:getattrintabs) Zz1Zz2ZtolabfaZfb_cacbdiffZaz1r6r6r7r<(sT=                  r<cCsB|\}}}}|s|stS|Sddlm}t||||||t}|S)aeReturn the mpf tuple normalized appropriately for the indicated precision after doing a check to see if zero should be returned or not when the mantissa is 0. ``mpf_normlize`` always assumes that this is zero, but it may not be since the mantissa for mpf's values "+inf", "-inf" and "nan" have a mantissa of zero, too. Note: this is not intended to validate a given mpf tuple, so sending mpf tuples that were not created by mpmath may produce bad results. This is only a wrapper to ``mpf_normalize`` which provides the check for non- zero mpfs that have a 0 for the mantissa. rr)r'mpmath.libmp.backendr mpf_normalizernd)mpfprecsignmanexptbcrrvr6r6r7mpf_norms  r]divideFcCstd|krt|td<dS)z Should SymPy raise an exception on 0/0 or return a nan? divide == True .... raise an exception divide == False ... return nan r^N)_errdictr)r^r6r6r7seterrs r`cCsdt|dt|j\}}}}ddg|d|}|dkrDd| }nd}|d|9}t|t|fS)N_mpf_rr/r)rImpmathrVrarJ)pZneg_powrYrZrOqr6r6r7_as_integer_ratios  rfcCs~|std||\}}}t|}|dkr@tt|}n6d|}tddtt|D}t ||d| }||fS)z3Convert an ordinary decimal instance to a Rational.zdec must be finite, got %s.rrbcSsg|]\}}|d|qS)r>r6)r4r5Zdir6r6r7r;sz-_decimal_to_Rational_prec..r>) is_finite TypeErroras_tuplelenIntegerrJsum enumeratereversedRational)decsderWr\r6r6r7_decimal_to_Rational_precs rtz[-+]?((\d*\.\d+)|(\d+\.?))cCstt|S)z5Return True if n starts like a floating point number.)bool _floatpatmatchfr6r6r7_literal_floatsrzicGst|dkrtdt|dd|D}d|kr6dS|}trh|D]}|rZt||n|}qFt|S|D]}t||}ql|S)aComputes nonnegative integer greatest common divisor. Explanation =========== The algorithm is based on the well known Euclid's algorithm [1]_. To improve speed, ``igcd()`` has its own caching mechanism. Examples ======== >>> from sympy import igcd >>> igcd(2, 4) 2 >>> igcd(5, 10, 15) 5 References ========== .. [1] https://en.wikipedia.org/wiki/Euclidean_algorithm r/z,igcd() takes at least 2 arguments (%s given)cSsg|]}tt|qSr6)rKr+r3r6r6r7r;szigcd..r)rjrhpoprrgcdr+math)argsZ args_temprLrMr6r6r7igcds  rcCstt|tt|}}||kr,||}}dtjj}||kr|dkr||}t||?t||?}}d\}}}} ||dkrqh||||} || ||| | } } | | dkr̐qh|| }}|| || || f\}}}} || dkrqh|||| } || ||| |} } | | dkr@qh|| }}|| | || | f\}}}} q|dkr|||}}q8||||||| |}}q8|r|||}}q|S)aComputes greatest common divisor of two integers. Explanation =========== Euclid's algorithm for the computation of the greatest common divisor ``gcd(a, b)`` of two (positive) integers $a$ and $b$ is based on the division identity $$ a = q \times b + r$$, where the quotient $q$ and the remainder $r$ are integers and $0 \le r < b$. Then each common divisor of $a$ and $b$ divides $r$, and it follows that ``gcd(a, b) == gcd(b, r)``. The algorithm works by constructing the sequence r0, r1, r2, ..., where r0 = a, r1 = b, and each rn is the remainder from the division of the two preceding elements. In Python, ``q = a // b`` and ``r = a % b`` are obtained by the floor division and the remainder operations, respectively. These are the most expensive arithmetic operations, especially for large a and b. Lehmer's algorithm [1]_ is based on the observation that the quotients ``qn = r(n-1) // rn`` are in general small integers even when a and b are very large. Hence the quotients can be usually determined from a relatively small number of most significant bits. The efficiency of the algorithm is further enhanced by not computing each long remainder in Euclid's sequence. The remainders are linear combinations of a and b with integer coefficients derived from the quotients. The coefficients can be computed as far as the quotients can be determined from the chosen most significant parts of a and b. Only then a new pair of consecutive remainders is computed and the algorithm starts anew with this pair. References ========== .. [1] https://en.wikipedia.org/wiki/Lehmer%27s_GCD_algorithm r/rrrrr)rKr+sysint_infobits_per_digit bit_lengthrJ)rLrMnbitsrFxyABCDreZx_qyZB_qDZA_qCr6r6r7 igcd_lehmers>,         $rcGsXt|dkrtdt|d|kr(dS|d}|ddD]}|t|||}q<|S)zComputes integer least common multiple. Examples ======== >>> from sympy import ilcm >>> ilcm(5, 10) 10 >>> ilcm(7, 3) 21 >>> ilcm(5, 10, 15) 30 r/z,ilcm() takes at least 2 arguments (%s given)rrN)rjrhr)r~rLrMr6r6r7ilcms  rc Cs|s |s dS|s&d|t|t|fS|s@|t|dt|fS|dkrV| d}}nd}|dkrp| d}}nd}d\}}}}|r||||}} |||| ||| |||f\}}}}}}q|||||fS)a0Returns x, y, g such that g = x*a + y*b = gcd(a, b). Examples ======== >>> from sympy.core.numbers import igcdex >>> igcdex(2, 3) (-1, 1, 1) >>> igcdex(10, 12) (-1, 1, 2) >>> x, y, g = igcdex(100, 2004) >>> x, y, g (-20, 1, 4) >>> x*100 + y*2004 4 )rrrrrbrr)rK) rLrMZx_signZy_signrrrrqcrer6r6r7igcdexs" .rcCsd}zFt|t|}}|dkrH|dkrHt||\}}}|dkrH||}Wnptk rt|t|}}|jrx|jsttd|dk}|tjtj fkrtd|n |rd|}YnX|dkrtd||f|S)a Return the number $c$ such that, $a \times c = 1 \pmod{m}$ where $c$ has the same sign as $m$. If no such value exists, a ValueError is raised. Examples ======== >>> from sympy import mod_inverse, S Suppose we wish to find multiplicative inverse $x$ of 3 modulo 11. This is the same as finding $x$ such that $3x = 1 \pmod{11}$. One value of x that satisfies this congruence is 4. Because $3 \times 4 = 12$ and $12 = 1 \pmod{11}$. This is the value returned by ``mod_inverse``: >>> mod_inverse(3, 11) 4 >>> mod_inverse(-3, 11) 7 When there is a common factor between the numerators of `a` and `m` the inverse does not exist: >>> mod_inverse(2, 4) Traceback (most recent call last): ... ValueError: inverse of 2 mod 4 does not exist >>> mod_inverse(S(2)/7, S(5)/2) 7/2 References ========== .. [1] https://en.wikipedia.org/wiki/Modular_multiplicative_inverse .. [2] https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm Nrrbz Expected numbers for arguments; symbolic `mod_inverse` is not implemented but symbolic expressions can be handled with the similar function, sympy.polys.polytools.invertz*m > 1 did not evaluate; try to simplify %sz%inverse of %s (mod %s) does not exist) r+rrBrr2rhr-r truefalse)rLmrrrOgbigr6r6r7 mod_inverses&'   rcseZdZdZdZdZdZdZdZe Z ddZ ddZ d d Z d d Zd dZddZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zed%d&ZedSd(d)Zed*e d+d,Z!ed*e d-d.Z"ed*e d/d0Z#ed*e d1d2Z$d3d4Z%d5d6Z&d7d8Z'd9d:Z(d;d<Z)d=d>Z*fd?d@Z+dAdBZ,ddCdDdEZ-dFdGZ.dTdIdJZ/dUdKdLZ0dMdNZ1dOdPZ2dQdRZ3Z4S)VNumberaRepresents atomic numbers in SymPy. Explanation =========== Floating point numbers are represented by the Float class. Rational numbers (of any size) are represented by the Rational class. Integer numbers (of any size) are represented by the Integer class. Float and Rational are subclasses of Number; Integer is a subclass of Rational. For example, ``2/3`` is represented as ``Rational(2, 3)`` which is a different object from the floating point number obtained with Python division ``2/3``. Even for numbers that are exactly represented in binary, there is a difference between how two forms, such as ``Rational(1, 2)`` and ``Float(0.5)``, are used in SymPy. The rational form is to be preferred in symbolic computations. Other kinds of numbers, such as algebraic numbers ``sqrt(2)`` or complex numbers ``3 + 4*I``, are not instances of Number class as they are not atomic. See Also ======== Float, Integer, Rational Tr6rbcGst|dkr|d}t|tr"|St|tr4t|St|trRt|dkrRt|St|ttj t j frnt |St|t r|}|dkrtjS|dkrtjS|dkrtjS|dkrtjSt|}t|tr|Std|d }t|t|jdS) Nrrr/naninf+inf-infz$String "%s" does not denote a Numberz %s)r rrhrrr6r6r7__gt__s  z Number.__gt__cCs@z t|}Wn$tk r0td||fYnXt||S)NzInvalid comparison %s >= %s)r rrhrrr6r6r7__ge__!s  z Number.__ge__cs tSr1super__hash__rrr6r7r(szNumber.__hash__cOsdS)NTr6)rZwrtflagsr6r6r7 is_constant+szNumber.is_constant)rationalcOs2|js |s|dfS|jr&tj| ffStj|ffSNr6) is_Rational is_negativer NegativeOner)rrdepskwargsr6r6r7 as_coeff_mul.s  zNumber.as_coeff_mulcGs|jr|dfStj|ffSr)rr r)rrr6r6r7 as_coeff_add6szNumber.as_coeff_addFcCs,|r|jstj|fS|r"|tjfStj|fSz1Efficiently extract the coefficient of a product.)rr rrrr6r6r7 as_coeff_Mul<s  zNumber.as_coeff_MulcCs|s|tjfStj|fSz3Efficiently extract the coefficient of a summation.r rrr6r6r7 as_coeff_AddBs zNumber.as_coeff_AddcCsddlm}|||S)z#Compute GCD of `self` and `other`. r)r|)rr|)rrr|r6r6r7r|Hs z Number.gcdcCsddlm}|||S)z#Compute LCM of `self` and `other`. r)lcm)rr)rrrr6r6r7rMs z Number.lcmcCsddlm}|||S)z1Compute GCD and cofactors of `self` and `other`. r) cofactors)rr)rrrr6r6r7rRs zNumber.cofactors)N)F)F)5r __module__ __qualname____doc__is_commutativer2 is_Number __slots__r:rkindrrrrrrrrrrrrrrrr classmethodrrrrrrrrrrrrrrrrrrrrrr|rr __classcell__r6r6rr7r,sd         rcseZdZUdZdZded<dZdZdZdZ dZ dZ dYddZ e dZd d Zd d Zd dZddZddZddZddZeddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Z d-d.Z!d/d0Z"e#d1e$d2d3Z%e#d1e$d4d5Z&e#d1e$d6d7Z'e#d1e$d8d9Z(e#d1e$d:d;Z)e#d1e$dd?Z+d@dAZ,dBdCZ-dDdEZ.dFdGZ/dHdIZ0dJdKZ1dLdMZ2dNdOZ3dPdQZ4fdRdSZ5d[dUdVZ6dWdXZ7Z8S)\rDa]Represent a floating-point number of arbitrary precision. Examples ======== >>> from sympy import Float >>> Float(3.5) 3.50000000000000 >>> Float(3) 3.00000000000000 Creating Floats from strings (and Python ``int`` and ``long`` types) will give a minimum precision of 15 digits, but the precision will automatically increase to capture all digits entered. >>> Float(1) 1.00000000000000 >>> Float(10**20) 100000000000000000000. >>> Float('1e20') 100000000000000000000. However, *floating-point* numbers (Python ``float`` types) retain only 15 digits of precision: >>> Float(1e20) 1.00000000000000e+20 >>> Float(1.23456789123456789) 1.23456789123457 It may be preferable to enter high-precision decimal numbers as strings: >>> Float('1.23456789123456789') 1.23456789123456789 The desired number of digits can also be specified: >>> Float('1e-3', 3) 0.00100 >>> Float(100, 4) 100.0 Float can automatically count significant figures if a null string is sent for the precision; spaces or underscores are also allowed. (Auto- counting is only allowed for strings, ints and longs). >>> Float('123 456 789.123_456', '') 123456789.123456 >>> Float('12e-3', '') 0.012 >>> Float(3, '') 3. If a number is written in scientific notation, only the digits before the exponent are considered significant if a decimal appears, otherwise the "e" signifies only how to move the decimal: >>> Float('60.e2', '') # 2 digits significant 6.0e+3 >>> Float('60e2', '') # 4 digits significant 6000. >>> Float('600e-2', '') # 3 digits significant 6.00 Notes ===== Floats are inexact by their nature unless their value is a binary-exact value. >>> approx, exact = Float(.1, 1), Float(.125, 1) For calculation purposes, evalf needs to be able to change the precision but this will not increase the accuracy of the inexact value. The following is the most accurate 5-digit approximation of a value of 0.1 that had only 1 digit of precision: >>> approx.evalf(5) 0.099609 By contrast, 0.125 is exact in binary (as it is in base 10) and so it can be passed to Float or evalf to obtain an arbitrary precision with matching accuracy: >>> Float(exact, 5) 0.12500 >>> exact.evalf(20) 0.12500000000000000000 Trying to make a high-precision Float from a float is not disallowed, but one must keep in mind that the *underlying float* (not the apparent decimal value) is being obtained with high precision. For example, 0.3 does not have a finite binary representation. The closest rational is the fraction 5404319552844595/2**54. So if you try to obtain a Float of 0.3 to 20 digits of precision you will not see the same thing as 0.3 followed by 19 zeros: >>> Float(0.3, 20) 0.29999999999999998890 If you want a 20-digit value of the decimal 0.3 (not the floating point approximation of 0.3) you should send the 0.3 as a string. The underlying representation is still binary but a higher precision than Python's float is used: >>> Float('0.3', 20) 0.30000000000000000000 Although you can increase the precision of an existing Float using Float it will not increase the accuracy -- the underlying value is not changed: >>> def show(f): # binary rep of Float ... from sympy import Mul, Pow ... s, m, e, b = f._mpf_ ... v = Mul(int(m), Pow(2, int(e), evaluate=False), evaluate=False) ... print('%s at prec=%s' % (v, f._prec)) ... >>> t = Float('0.3', 3) >>> show(t) 4915/2**14 at prec=13 >>> show(Float(t, 20)) # higher prec, not higher accuracy 4915/2**14 at prec=70 >>> show(Float(t, 2)) # lower prec 307/2**10 at prec=10 The same thing happens when evalf is used on a Float: >>> show(t.evalf(20)) 4915/2**14 at prec=70 >>> show(t.evalf(2)) 307/2**10 at prec=10 Finally, Floats can be instantiated with an mpf tuple (n, c, p) to produce the number (-1)**n*c*2**p: >>> n, c, p = 1, 5, 0 >>> (-1)**n*c*2**p -5 >>> Float((1, 5, 0)) -5.00000000000000 An actual mpf tuple also contains the number of bits in c as the last element of the tuple: >>> _._mpf_ (1, 5, 0, 3) This is not needed for instantiation and is not the same thing as the precision. The mpf tuple and the precision are two separate quantities that Float tracks. In SymPy, a Float is a number that can be computed with arbitrary precision. Although floating point 'inf' and 'nan' are not such numbers, Float can create these numbers: >>> Float('-inf') -oo >>> _.is_Float False Zero in Float only has a single value. Values are not separate for positive and negative zeroes. rar:ztuple[int, int, int, int]raNTc CsH|dk r|dk rtdt|tr|dd}|drRt|dkrRd|}nD|drzt|dkrzd |dd}n|d krtjS|d krtj Snt|t r|d krd}nt|t r|t d krtjSt|t r|t d krtj St|t rt |rtj St|ttfr"t|}nt|tjkr2|S|tj krB|S|tj krR|St|rft|}n0t|tjr|dkr|dkr|jj}|j}|dkrJ|dkrJd}t|tr|St|trt|rzt|}Wntjk rYnNXd|k}t|\}}|jr6|r6t|tt|d}td|}t |}n|dkr^|dksr|dkr|dkrt|tstdd}t|rzt|}Wntjk rYnHXd|k}t|\}}|jr|rt|tt|d}t |}d}|dkrtd||dks,|dkr4t |}t!|}t|t rZt"#||t$}nt|trxt"%||t$}nt|tjr|&rt"%t||t$}n@|'rtj S|(r|d krtjStj Stdt|nPt|t)rt|dkrt|dtr~t*|}|d+dr>|ddd|d<|ddrb|ddd|d<t,|dd|d<t)|}n~t|dkrt-||St.|d dk|dd kt.dd|Dfstd|ft-|d |d|dt/|df|Sn:z|0|}Wn*t1t2fk r6tj||dj}YnX|j-||dd S)!Nz=Both decimal and binary precision supplied. Supply only one.  r0.r0z-.r/z-0.)rrrrr-z^The null string can only be used when the number to Float is passed as a string or an integer.Tzstring-float not recognized: %szunexpected decimal value %s)Lrb0xr)rrcss|]}t|ttfkVqdSr1)rrJr3r6r6r7r8sz Float.__new__..zmalformed mpf: %s)rWF)zero)3rBr@rAreplacer startswithrjr rrrr}isnanrrrkr r rcrVcontextrWrarDrzrrInvalidOperationrtrrlstripr*rJr from_floatrUZfrom_strrgis_nanrrlistendswithrrrCrrrAttributeError)rnumZdps precisionNumZisintokrar6r6r7r s               (               z Float.__new__cCs\|r|tkrtjS|tkr tjS|tkr.tjS|tkr exp(r*log(-p)) -> exp(r*(log(p) + I*Pi)) -> -> p**r*(sin(Pi*r) + cos(Pi*r)*I) rrr/FrN) equal_valuedis_extended_positiverr ComplexInfinityr@rrkr:rDrrZ mpf_pow_intrardrUrorerPowr _eval_powerrrZ ComplexResultZmpc_powr' ImaginaryUnit)rrZrWZmpfselfrreZimr6r6r7rL4sN     zFloat._eval_powercCstt|j|jSr1)rDrrZmpf_absrar:rr6r6r7__abs__Tsz Float.__abs__cCs|jtkrdStt|jSrB)rar'rJrr-rr6r6r7__int__Ws z Float.__int__cCsddlm}z t|}Wntk r0tYSXt||r@dS|jrZ|jrPdS||S|j rl|j |j kS|j r|||S|j r| |j}tt|j |S|s| SdS)Nr)BooleanF)Zsympy.logic.boolalgrQr rrr@is_NumberSymbol is_irrationalris_Floatrarrrr:rurZmpf_eq)rrrQompfr6r6r7r\s*        z Float.__eq__cCs ||k Sr1r6rr6r6r7rzsz Float.__ne__cCsz t|}Wntk r$tYSX|jr`t|jt|j}t|j }tt |||S|j r|tt ||j|jS|j r|t jt jfkr|t|j}|jdkr|jrtt ||j||jSdSNr)r rrrrrArafrom_intrerdrurT is_comparabler rrevalfr)r:rr)rropZsmpfrUr6r6r7_Frel}s,      z Float._FrelcCs:t|tr||S||tj}|dkr6t||S|Sr1)r@ NumberSymbolrr[rZmpf_gtrrrrr\r6r6r7rs    z Float.__gt__cCs:t|tr||S||tj}|dkr6t||S|Sr1)r@r\rr[rZmpf_gerrr]r6r6r7rs    z Float.__ge__cCs:t|tr||S||tj}|dkr6t||S|Sr1)r@r\rr[rZmpf_ltrrr]r6r6r7rs    z Float.__lt__cCs:t|tr||S||tj}|dkr6t||S|Sr1)r@r\rr[rZmpf_lerrr]r6r6r7rs    z Float.__le__cs tSr1rrrr6r7rszFloat.__hash__1e-15cCst||t|kSr1)rKrD)rrepsilonr6r6r7 epsilon_eqszFloat.epsilon_eqcCsttt||Sr1)formatrrrA)r format_specr6r6r7 __format__szFloat.__format__)NN)T)r^)9rrrrr __annotations__ is_rationalrSr2is_realis_extended_realrTrr rr+r,rrrrpropertyr$rrr0r2r4r7r8r:r;r<r=r>rrrrrrrDrFrLrOrPrrr[rrrrrr`rcr r6r6rr7rDXsv &            rDcseZdZUdZdZdZdZdZdZde d<de d<dZ e d]d d Z d^d d Z ddZddZddZddZddZededdZeZededdZededdZededd ZeZeded!d"Zeded#d$Zeded%d&Zeded'd(Zd)d*Zd+d,Z d-d.Z!d/d0Z"d1d2Z#d3d4Z$d5d6Z%d7d8Z&d9d:Z'd;d<Z(d=d>Z)d?d@Z*dAdBZ+dCdDZ,dEdFZ-dGdHZ.fdIdJZ/d_dKdLZ0e1dMdNZ2e1dOdPZ3ededQdRZ4ededSdTZ5dUdVZ6d`dWdXZ7dadYdZZ8dbd[d\Z9Z:S)croaRepresents rational numbers (p/q) of any size. Examples ======== >>> from sympy import Rational, nsimplify, S, pi >>> Rational(1, 2) 1/2 Rational is unprejudiced in accepting input. If a float is passed, the underlying value of the binary representation will be returned: >>> Rational(.5) 1/2 >>> Rational(.2) 3602879701896397/18014398509481984 If the simpler representation of the float is desired then consider limiting the denominator to the desired value or convert the float to a string (which is roughly equivalent to limiting the denominator to 10**12): >>> Rational(str(.2)) 1/5 >>> Rational(.2).limit_denominator(10**12) 1/5 An arbitrarily precise Rational is obtained when a string literal is passed: >>> Rational("1.23") 123/100 >>> Rational('1e-2') 1/100 >>> Rational(".1") 1/10 >>> Rational('1e-2/3.2') 1/320 The conversion of other types of strings can be handled by the sympify() function, and conversion of floats to expressions or simple fractions can be handled with nsimplify: >>> S('.[3]') # repeating digits in brackets 1/3 >>> S('3**2/10') # general expressions 9/10 >>> nsimplify(.3) # numbers that have a simple form 3/10 But if the input does not reduce to a literal Rational, an error will be raised: >>> Rational(pi) Traceback (most recent call last): ... TypeError: invalid input: pi Low-level --------- Access numerator and denominator as .p and .q: >>> r = Rational(3, 4) >>> r 3/4 >>> r.p 3 >>> r.q 4 Note that p and q return integers (not SymPy Integers) so some care is needed when using them in expressions: >>> r.p/r.q 0.75 If an unevaluated Rational is desired, ``gcd=1`` can be passed and this will keep common divisors of the numerator and denominator from being eliminated. It is not possible, however, to leave a negative value in the denominator. >>> Rational(2, 4, gcd=1) 2/4 >>> Rational(2, -4, gcd=1).q 4 See Also ======== sympy.core.sympify.sympify, sympy.simplify.simplify.nsimplify TFrdrerJrdreNc CsP|dkr&t|tr|St|tr$nt|ttfr>tt|St|tspz t|}Wntt fk rlYnXn| ddkrt d|| dd}| dd}t|dkr|\}}t|}t|}||}zt|}Wntk rYnXt|j|jdSt|tst d|d}d}d}t|tsPt|}||j9}|j}nt|}t|tst|}||j9}||j9}n |t|9}|}|dkr|dkrtdrtd ntjStjS|dkr| }| }|stt||}|dkr ||}||}|dkrt|S|dkr6|dkr6tjSt |}||_||_|S) N/rzinvalid input: %srr0r/rr^zIndeterminate 0/0)!r@rorrrDrfrArr SyntaxErrorcountrhrrsplitrj fractionsFractionrB numerator denominatorrerdrJr_r rrJrrKrkHalfrr) rrdrer|ZpqfpZfqQrr6r6r7r4s                            zRational.__new__@BcCs(t|j|j}t|tt|S)a4Closest Rational to self with denominator at most max_denominator. Examples ======== >>> from sympy import Rational >>> Rational('3.141592653589793').limit_denominator(10) 22/7 >>> Rational('3.141592653589793').limit_denominator(100) 311/99 )rnrordrerolimit_denominatorrJ)rmax_denominatorryr6r6r7rvs zRational.limit_denominatorcCs |j|jfSr1rirr6r6r7__getnewargs__szRational.__getnewargs__cCs |j|jfSr1rirr6r6r7r,szRational._hashable_contentcCs |jdkSrBrdrr6r6r7r8szRational._eval_is_positivecCs |jdkSrBryrr6r6r7r<szRational._eval_is_zerocCst|j |jSr1)rordrerr6r6r7r>szRational.__neg__rcCstjrzt|tr,t|j|j|j|jdSt|tr\t|j|j|j|j|j|jSt|trn||St ||St ||SrV) r.rr@rkrordrerDrrrr6r6r7rs  &  zRational.__add__cCstjr|t|tr,t|j|j|j|jdSt|tr\t|j|j|j|j|j|jSt|trp| |St ||St ||SrV) r.rr@rkrordrerDrrrr6r6r7rs  &   zRational.__sub__cCstjr|t|tr,t|j|j|j|jdSt|tr\t|j|j|j|j|j|jSt|trp| |St ||St ||SrV) r.rr@rkrorerdrDr__rsub__rr6r6r7rzs  &   zRational.__rsub__cCstjrt|tr0t|j|j|jt|j|jSt|trnt|j|j|j|jt|j|jt|j|jSt|tr||St ||St ||Sr1) r.rr@rkrordrerrDrrrr6r6r7rs   4  zRational.__mul__cCstjrt|trJ|jr(|jtjkr(tjSt|j|j |jt |j|jSn`t|trt|j|j |j |jt |j|jt |j |j St|t r|d|St ||St ||SrV)r.rr@rkrdr rrJrorerrDrrrr6r6r7rs " 4   zRational.__truediv__cCstjrt|tr0t|j|j|jt|j|jSt|trnt|j|j|j|jt|j|jt|j|jSt|tr|d|St ||St ||SrV) r.rr@rkrordrerrDr __rtruediv__rr6r6r7r{s   4   zRational.__rtruediv__cCstjrt|trR|j|j|j|j}t|j|j||j|j|j|jSt|trtt|t||jdSt ||St ||S)NrC) r.rr@rordrerDrDr:r)rrrFr6r6r7rDs *  zRational.__mod__cCs"t|trt||St||Sr1)r@rorDrrFrr6r6r7rFs  zRational.__rmod__cCs t|trt|tr&||j|S|jr| }|tjkrJt|j |j S|j rntj |t|j |j |St|j |j |S|tj kr|j |j krtj S|j |j krtj tj tjStjSt|trt|j |j |j |j dSt|tr|j |j }|r|d7}||j |j }t||j }|j dkrdt|j |t|j |td|j |dSt|j |td|j |dS|j |j }t||j }|j dkrt|j |t|j |td|j dSt|j |td|j dS|jr|jr| |SdSrV)r@rrDrr:rr rrorerdrrrrMrrkis_even)rrZneZintpartZ remfracpartZ ratfracpartr6r6r7rLsF          .    * zRational._eval_powercCst|j|j|tSr1)r from_rationalrdrerUrr6r6r7r5szRational._as_mpf_valcCstt|j|j||Sr1)rcmake_mpfrr~rdrerrWrUr6r6r7_mpmath_8szRational._mpmath_cCstt|j|jSr1)rorKrdrerr6r6r7rO;szRational.__abs__cCs2|j|j}}|dkr&t| | St||SrB)rdrerJ)rrdrer6r6r7rP>szRational.__int__cCst|j|jSr1rkrdrerr6r6r7rDszRational.floorcCst|j |j Sr1rrr6r6r7rGszRational.ceilingcCs|Sr1rrr6r6r7rJszRational.__floor__cCs|Sr1rrr6r6r7rMszRational.__ceil__cCsNz t|}Wntk r$tYSXt|ts4dS|s>| S|jrX|jrNdS||S|jrv|j |j kot|j |j kS|j rJ|j |j d@rdS|j dd\}}}|r| }|s|j r|jrdS||j kSddlm}|dkr|j sdS|j o|j | o||j |d|dfkS|j r(dS||j koH||j d| dfkSdS)NFrr) integer_logrr/T)r rrr@rrRrSrrrdrerTrarr|powerr)rrrqrtrr6r6r7rPsF        "zRational.__eq__cCs ||k Sr1r6rr6r6r7rszRational.__ne__cCsz t|}Wntk r$tYSX|jrd}||}}|jrLt||}nD|jr^t||}n2|jrt|j |j t|j |j }}t||}|r||S|j r|j rt|j |j |fSdSr1) r rrrrRrIrTrrkrdrer2rg)rrattrrZrqor6r6r7_Rrels$     "  zRational._RrelcCs6||d}|dkr||f}nt|ts,|Stj|S)Nr)rr@rrrr]r6r6r7rs    zRational.__gt__cCs6||d}|dkr||f}nt|ts,|Stj|S)Nr)rr@rrrr]r6r6r7rs    zRational.__ge__cCs6||d}|dkr||f}nt|ts,|Stj|S)Nr)rr@rrrr]r6r6r7rs    zRational.__lt__cCs6||d}|dkr||f}nt|ts,|Stj|S)Nr)rr@rrrr]r6r6r7rs    zRational.__le__cs tSr1rrrr6r7rszRational.__hash__cCs$ddlm}|||||||dS)zA wrapper to factorint which return factors of self that are smaller than limit (or cheap to compute). Special methods of factoring are disabled by default so that only trial division is used. r) factorrat)limit use_trialuse_rhouse_pm1verbose)sympy.ntheory.factor_rcopy)rrrrrrvisualrr6r6r7factorss  zRational.factorscCs|jSr1ryrr6r6r7rpszRational.numeratorcCs|jSr1)rerr6r6r7rqszRational.denominatorcCsBt|tr6|tjkr|Stt|j|jt|j|jSt ||Sr1) r@ror rrrdrrerr|rr6r6r7r|s    z Rational.gcdcCs@t|tr4t|jt|j|j|jt|j|jSt||Sr1)r@rordrrerrrr6r6r7rs   z Rational.lcmcCst|jt|jfSr1rrr6r6r7as_numer_denomszRational.as_numer_denomcCs*|r |jr|tjfS| tjfStj|fS)a-Return the tuple (R, self/R) where R is the positive Rational extracted from self. Examples ======== >>> from sympy import S >>> (S(-3)/2).as_content_primitive() (3/2, -1) See docstring of Expr.as_content_primitive for more examples. )rr rr)rradicalclearr6r6r7as_content_primitives   zRational.as_content_primitivecCs |tjfSrr rrr6r6r7rszRational.as_coeff_MulcCs |tjfSrrrr6r6r7rszRational.as_coeff_Add)NN)ru)NTFFFF)FT)F)F);rrrrrf is_integerrer2r rdrrrrvrxr,r8r<r>rrr__radd__rrzr__rmul__rr{rDrFrLrrrOrPrrrrrrrrrrrrrrhrprqr|rrrrrr r6r6rr7ros \ P         -/        rocseZdZdZdZdZdZdZdZddZ ddZ e d d Z d d Z d dZddZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Z d3d4Z!d5d6Z"d7d8Z#d9d:Z$d;d<Z%d=d>Z&d?d@Z'fdAdBZ(dCdDZ)dEdFZ*dGdHZ+e,dIe-dJdKZ.dLdMZ/dNdOZ0dPdQZ1dRdSZ2dTdUZ3dVdWZ4dXdYZ5dZd[Z6d\d]Z7d^d_Z8d`daZ9dbdcZ:Z;S)drkajRepresents integer numbers of any size. Examples ======== >>> from sympy import Integer >>> Integer(3) 3 If a float or a rational is passed to Integer, the fractional part will be discarded; the effect is of rounding toward zero. >>> Integer(3.8) 3 >>> Integer(-3.8) -3 A string is acceptable input if it can be parsed as an integer: >>> Integer("9" * 20) 99999999999999999999 It is rarely needed to explicitly instantiate an Integer, because Python integers are automatically converted to Integer when they are used in SymPy expressions. rTr6cCst|j|tSr1)rrWrdrUrr6r6r7r#szInteger._as_mpf_valcCst||Sr1)rcrrrr6r6r7r&szInteger._mpmath_cCst|tr|dd}z t|}Wn tk rBtd|YnX|dkrRtjS|dkr`tjS|dkrntjSt |}||_ |S)Nrr0z6Argument of Integer should be of numeric type, got %s.rrbr) r@rArrJrhr rrrrrrd)rr5Zivalrr6r6r7r)s"     zInteger.__new__cCs|jfSr1ryrr6r6r7rxDszInteger.__getnewargs__cCs|jSr1ryrr6r6r7rPHszInteger.__int__cCs t|jSr1rkrdrr6r6r7rKsz Integer.floorcCs t|jSr1rrr6r6r7rNszInteger.ceilingcCs|Sr1rrr6r6r7rQszInteger.__floor__cCs|Sr1rrr6r6r7rTszInteger.__ceil__cCs t|j Sr1rrr6r6r7r>WszInteger.__neg__cCs|jdkr|St|j SdSrB)rdrkrr6r6r7rOZs zInteger.__abs__cCs2t|tr"tjr"tt|j|jSt||SdSr1) r@rkr.rrrrdrrrr6r6r7r`szInteger.__divmod__cCszt|tr tjr tt||jSz t|}Wn<tk rhd}t |j }t |j }t|||fYnXt ||SdS)Nz7unsupported operand type(s) for divmod(): '%s' and '%s') r@rJr.rrrrdrrhrrr)rrrZonameZsnamer6r6r7rfs   zInteger.__rdivmod__cCsxtjrjt|trt|j|St|tr8t|j|jSt|tr^t|j|j|j|jdSt||St ||SdSrV) r.rr@rJrkrdrorerAddrr6r6r7rts    zInteger.__add__cCs\tjrPt|trt||jSt|trDt|j|j|j|jdSt||St||SrV) r.rr@rJrkrdrorerrr6r6r7rs   zInteger.__radd__cCsvtjrjt|trt|j|St|tr8t|j|jSt|tr^t|j|j|j|jdSt||St||SrV) r.rr@rJrkrdrorerrr6r6r7rs    zInteger.__sub__cCs\tjrPt|trt||jSt|trDt|j|j|j|jdSt||St||SrV) r.rr@rJrkrdrorerzrr6r6r7rzs   zInteger.__rsub__cCsztjrnt|trt|j|St|tr8t|j|jSt|trbt|j|j|jt|j|jSt ||St ||Sr1) r.rr@rJrkrdrorerrrr6r6r7rs     zInteger.__mul__cCs`tjrTt|trt||jSt|trHt|j|j|jt|j|jSt ||St ||Sr1) r.rr@rJrkrdrorerrrr6r6r7rs    zInteger.__rmul__cCsPtjrDt|trt|j|St|tr8t|j|jSt||St||Sr1)r.rr@rJrkrdrorDrr6r6r7rDs   zInteger.__mod__cCsPtjrDt|trt||jSt|tr8t|j|jSt||St||Sr1)r.rr@rJrkrdrorFrr6r6r7rFs   zInteger.__rmod__cCs6t|tr|j|kSt|tr*|j|jkSt||Sr1)r@rJrdrkrorrr6r6r7rs     zInteger.__eq__cCs ||k Sr1r6rr6r6r7rszInteger.__ne__cCsHz t|}Wntk r$tYSX|jrStSdSr1r@rJrknumbersIntegralrdrrr6r6r7 __lshift__ szInteger.__lshift__cCs*t|ttjfr"tt||j>StSdSr1r@rJrrrkrdrrr6r6r7 __rlshift__ szInteger.__rlshift__cCs,t|tttjfr$t|jt|?StSdSr1rrr6r6r7 __rshift__ szInteger.__rshift__cCs*t|ttjfr"tt||j?StSdSr1rrr6r6r7 __rrshift__ szInteger.__rrshift__cCs,t|tttjfr$t|jt|@StSdSr1rrr6r6r7__and__ szInteger.__and__cCs*t|ttjfr"tt||j@StSdSr1rrr6r6r7__rand__ szInteger.__rand__cCs,t|tttjfr$t|jt|AStSdSr1rrr6r6r7__xor__ szInteger.__xor__cCs*t|ttjfr"tt||jAStSdSr1rrr6r6r7__rxor__ szInteger.__rxor__cCs,t|tttjfr$t|jt|BStSdSr1rrr6r6r7__or__ szInteger.__or__cCs*t|ttjfr"tt||jBStSdSr1rrr6r6r7__ror__ szInteger.__ror__cCs t|jSr1rrr6r6r7 __invert__ szInteger.__invert__)rOrrrrrrzrrrDrFrrrrrrrrrrLrrrrrrrrrrrrrrrrrrr r6r6rr7rksn              l  rkcseZdZUdZdZdZdZdZeZ e Z de d<d'ddZ fd d Zd d Zed dZd(ddZd)ddZddZddZddZddZddZeddZdd Zd*d!d"Zd#d$Zd+d%d&ZZS),AlgebraicNumbera4 Class for representing algebraic numbers in SymPy. Symbolically, an instance of this class represents an element $\alpha \in \mathbb{Q}(\theta) \hookrightarrow \mathbb{C}$. That is, the algebraic number $\alpha$ is represented as an element of a particular number field $\mathbb{Q}(\theta)$, with a particular embedding of this field into the complex numbers. Formally, the primitive element $\theta$ is given by two data points: (1) its minimal polynomial (which defines $\mathbb{Q}(\theta)$), and (2) a particular complex number that is a root of this polynomial (which defines the embedding $\mathbb{Q}(\theta) \hookrightarrow \mathbb{C}$). Finally, the algebraic number $\alpha$ which we represent is then given by the coefficients of a polynomial in $\theta$. )reprootaliasminpoly _own_minpolyTz set[Basic] free_symbolsNcKsddlm}m}ddlm}t|}d}d} t|ttfr^|\} } | j sddl m } | | } n>|j r|j |j|j|jf\} } }} n|||ddd|} } | } |dk rt||s|t|d| }t|}n||d| }t|}n|d dgd| }td d}|dk rJdd lm}||j|j| }||d| }t|}|| krh|| j}| |f}|px| }|dk rd d lm}t||s||}||f}tj|f|}||_| |_||_| |_ d|_|S) a] Construct a new algebraic number $\alpha$ belonging to a number field $k = \mathbb{Q}(\theta)$. There are four instance attributes to be determined: =========== ============================================================================ Attribute Type/Meaning =========== ============================================================================ ``root`` :py:class:`~.Expr` for $\theta$ as a complex number ``minpoly`` :py:class:`~.Poly`, the minimal polynomial of $\theta$ ``rep`` :py:class:`~sympy.polys.polyclasses.DMP` giving $\alpha$ as poly in $\theta$ ``alias`` :py:class:`~.Symbol` for $\theta$, or ``None`` =========== ============================================================================ See Parameters section for how they are determined. Parameters ========== expr : :py:class:`~.Expr`, or pair $(m, r)$ There are three distinct modes of construction, depending on what is passed as *expr*. **(1)** *expr* is an :py:class:`~.AlgebraicNumber`: In this case we begin by copying all four instance attributes from *expr*. If *coeffs* were also given, we compose the two coeff polynomials (see below). If an *alias* was given, it overrides. **(2)** *expr* is any other type of :py:class:`~.Expr`: Then ``root`` will equal *expr*. Therefore it must express an algebraic quantity, and we will compute its ``minpoly``. **(3)** *expr* is an ordered pair $(m, r)$ giving the ``minpoly`` $m$, and a ``root`` $r$ thereof, which together define $\theta$. In this case $m$ may be either a univariate :py:class:`~.Poly` or any :py:class:`~.Expr` which represents the same, while $r$ must be some :py:class:`~.Expr` representing a complex number that is a root of $m$, including both explicit expressions in radicals, and instances of :py:class:`~.ComplexRootOf` or :py:class:`~.AlgebraicNumber`. coeffs : list, :py:class:`~.ANP`, None, optional (default=None) This defines ``rep``, giving the algebraic number $\alpha$ as a polynomial in $\theta$. If a list, the elements should be integers or rational numbers. If an :py:class:`~.ANP`, we take its coefficients (using its :py:meth:`~.ANP.to_list()` method). If ``None``, then the list of coefficients defaults to ``[1, 0]``, meaning that $\alpha = \theta$ is the primitive element of the field. If *expr* was an :py:class:`~.AlgebraicNumber`, let $g(x)$ be its ``rep`` polynomial, and let $f(x)$ be the polynomial defined by *coeffs*. Then ``self.rep`` will represent the composition $(f \circ g)(x)$. alias : str, :py:class:`~.Symbol`, None, optional (default=None) This is a way to provide a name for the primitive element. We described several ways in which the *expr* argument can define the value of the primitive element, but none of these methods gave it a name. Here, for example, *alias* could be set as ``Symbol('theta')``, in order to make this symbol appear when $\alpha$ is printed, or rendered as a polynomial, using the :py:meth:`~.as_poly()` method. Examples ======== Recall that we are constructing an algebraic number as a field element $\alpha \in \mathbb{Q}(\theta)$. >>> from sympy import AlgebraicNumber, sqrt, CRootOf, S >>> from sympy.abc import x Example (1): $\alpha = \theta = \sqrt{2}$ >>> a1 = AlgebraicNumber(sqrt(2)) >>> a1.minpoly_of_element().as_expr(x) x**2 - 2 >>> a1.evalf(10) 1.414213562 Example (2): $\alpha = 3 \sqrt{2} - 5$, $\theta = \sqrt{2}$. We can either build on the last example: >>> a2 = AlgebraicNumber(a1, [3, -5]) >>> a2.as_expr() -5 + 3*sqrt(2) or start from scratch: >>> a2 = AlgebraicNumber(sqrt(2), [3, -5]) >>> a2.as_expr() -5 + 3*sqrt(2) Example (3): $\alpha = 6 \sqrt{2} - 11$, $\theta = \sqrt{2}$. Again we can build on the previous example, and we see that the coeff polys are composed: >>> a3 = AlgebraicNumber(a2, [2, -1]) >>> a3.as_expr() -11 + 6*sqrt(2) reflecting the fact that $(2x - 1) \circ (3x - 5) = 6x - 11$. Example (4): $\alpha = \sqrt{2}$, $\theta = \sqrt{2} + \sqrt{3}$. The easiest way is to use the :py:func:`~.to_number_field()` function: >>> from sympy import to_number_field >>> a4 = to_number_field(sqrt(2), sqrt(2) + sqrt(3)) >>> a4.minpoly_of_element().as_expr(x) x**2 - 2 >>> a4.to_root() sqrt(2) >>> a4.primitive_element() sqrt(2) + sqrt(3) >>> a4.coeffs() [1/2, 0, -9/2, 0] but if you already knew the right coefficients, you could construct it directly: >>> a4 = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1)/2, 0, S(-9)/2, 0]) >>> a4.to_root() sqrt(2) >>> a4.primitive_element() sqrt(2) + sqrt(3) Example (5): Construct the Golden Ratio as an element of the 5th cyclotomic field, supposing we already know its coefficients. This time we introduce the alias $\zeta$ for the primitive element of the field: >>> from sympy import cyclotomic_poly >>> from sympy.abc import zeta >>> a5 = AlgebraicNumber(CRootOf(cyclotomic_poly(5), -1), ... [-1, -1, 0, 0], alias=zeta) >>> a5.as_poly().as_expr() -zeta**3 - zeta**2 >>> a5.evalf() 1.61803398874989 (The index ``-1`` to ``CRootOf`` selects the complex root with the largest real and imaginary parts, which in this case is $\mathrm{e}^{2i\pi/5}$. See :py:class:`~.ComplexRootOf`.) Example (6): Building on the last example, construct the number $2 \phi \in \mathbb{Q}(\phi)$, where $\phi$ is the Golden Ratio: >>> from sympy.abc import phi >>> a6 = AlgebraicNumber(a5.to_root(), coeffs=[2, 0], alias=phi) >>> a6.as_poly().as_expr() 2*phi >>> a6.primitive_element().evalf() 1.61803398874989 Note that we needed to use ``a5.to_root()``, since passing ``a5`` as the first argument would have constructed the number $2 \phi$ as an element of the field $\mathbb{Q}(\zeta)$: >>> a6_wrong = AlgebraicNumber(a5, coeffs=[2, 0]) >>> a6_wrong.as_poly().as_expr() -2*zeta**3 - 2*zeta**2 >>> a6_wrong.primitive_element().evalf() 0.309016994374947 + 0.951056516295154*I r)ANPDMP)minimal_polynomialNPolygenTZpolysr) dup_compose)Symbol)Zsympy.polys.polyclassesrrZsympy.polys.numberfieldsrrr@rrZis_Polyrris_AlgebraicNumberrrrrgetZ get_domainZfrom_sympy_list from_listZto_listZsympy.polys.densetoolsrdegreeremsymbolrrrr)rexprcoeffsrr~rrrZrep0Zalias0rrrdomrZscoeffsrrZsargsrrr6r6r7r sj*              zAlgebraicNumber.__new__cs tSr1rrrr6r7r szAlgebraicNumber.__hash__cCs||Sr1)as_exprZ_evalfrr6r6r7r szAlgebraicNumber._eval_evalfcCs |jdk S)z'Returns ``True`` if ``alias`` was set. N)rrr6r6r7 is_aliased szAlgebraicNumber.is_aliasedcCsbddlm}m}|dk r&||j|S|jdk r@||j|jSddlm}||j|dSdS)z&Create a Poly instance from ``self``. r)rPurePolyNrDummyr)rrrrrrrr)rrrrrr6r6r7as_poly s  zAlgebraicNumber.as_polycCs||p |jS)z)Create a Basic expression from ``self``. )rrrexpand)rrr6r6r7r szAlgebraicNumber.as_exprcsfddjDS)z7Returns all SymPy coefficients of an algebraic number. csg|]}jj|qSr6)rrZto_sympy)r4rrr6r7r; sz*AlgebraicNumber.coeffs..rZ all_coeffsrr6rr7r szAlgebraicNumber.coeffscCs |jS)z8Returns all native coefficients of an algebraic number. rrr6r6r7 native_coeffs szAlgebraicNumber.native_coeffscCsvddlm}|j}|dkr"|S||d}|||j|}||}||j}t||f| S)z*Convert ``self`` to an algebraic integer. rrr) rrrZLCrZcomposerrrr)rrrycoeffZpolyrrr6r6r7to_algebraic_integer s  z$AlgebraicNumber.to_algebraic_integerc s~ddlmddlm}|d|d}}fdd|jDD]6}||j|jrB|||||jkrBt|SqB|S)NrCRootOfrmeasureratiocsg|]}|jkr|qSr6)func)r4rrr6r7r; s z2AlgebraicNumber._eval_simplify..)Zsympy.polys.rootoftoolsrZ sympy.polysr all_rootsrZ is_Symbolr)rrrrrrr6rr7_eval_simplify s  zAlgebraicNumber._eval_simplifycCst|j|jf||jdS)a\ Form another element of the same number field. Explanation =========== If we represent $\alpha \in \mathbb{Q}(\theta)$, form another element $\beta \in \mathbb{Q}(\theta)$ of the same number field. Parameters ========== coeffs : list, :py:class:`~.ANP` Like the *coeffs* arg to the class :py:meth:`constructor<.AlgebraicNumber.__new__>`, defines the new element as a polynomial in the primitive element. If a list, the elements should be integers or rational numbers. If an :py:class:`~.ANP`, we take its coefficients (using its :py:meth:`~.ANP.to_list()` method). Examples ======== >>> from sympy import AlgebraicNumber, sqrt >>> a = AlgebraicNumber(sqrt(5), [-1, 1]) >>> b = a.field_element([3, 2]) >>> print(a) 1 - sqrt(5) >>> print(b) 2 + 3*sqrt(5) >>> print(b.primitive_element() == a.primitive_element()) True See Also ======== AlgebraicNumber )rr)rrrr)rrr6r6r7 field_element s ( zAlgebraicNumber.field_elementcCs |}|ddgkp||jgkS)z Say whether this algebraic number $\alpha \in \mathbb{Q}(\theta)$ is equal to the primitive element $\theta$ for its field. rr)rr)rrr6r6r7is_primitive_element= sz$AlgebraicNumber.is_primitive_elementcCs|jr |S|ddgS)z Get the primitive element $\theta$ for the number field $\mathbb{Q}(\theta)$ to which this algebraic number $\alpha$ belongs. Returns ======= AlgebraicNumber rr)rrrr6r6r7primitive_elementG s z!AlgebraicNumber.primitive_elementcCs*|jr |S|}|j|d}t||fS)a Convert ``self`` to an :py:class:`~.AlgebraicNumber` instance that is equal to its own primitive element. Explanation =========== If we represent $\alpha \in \mathbb{Q}(\theta)$, $\alpha \neq \theta$, construct a new :py:class:`~.AlgebraicNumber` that represents $\alpha \in \mathbb{Q}(\alpha)$. Examples ======== >>> from sympy import sqrt, to_number_field >>> from sympy.abc import x >>> a = to_number_field(sqrt(2), sqrt(2) + sqrt(3)) The :py:class:`~.AlgebraicNumber` ``a`` represents the number $\sqrt{2}$ in the field $\mathbb{Q}(\sqrt{2} + \sqrt{3})$. Rendering ``a`` as a polynomial, >>> a.as_poly().as_expr(x) x**3/2 - 9*x/2 reflects the fact that $\sqrt{2} = \theta^3/2 - 9 \theta/2$, where $\theta = \sqrt{2} + \sqrt{3}$. ``a`` is not equal to its own primitive element. Its minpoly >>> a.minpoly.as_poly().as_expr(x) x**4 - 10*x**2 + 1 is that of $\theta$. Converting to a primitive element, >>> a_prim = a.to_primitive_element() >>> a_prim.minpoly.as_poly().as_expr(x) x**2 - 2 we obtain an :py:class:`~.AlgebraicNumber` whose ``minpoly`` is that of the number itself. Parameters ========== radicals : boolean, optional (default=True) If ``True``, then we will try to return an :py:class:`~.AlgebraicNumber` whose ``root`` is an expression in radicals. If that is not possible (or if *radicals* is ``False``), ``root`` will be a :py:class:`~.ComplexRootOf`. Returns ======= AlgebraicNumber See Also ======== is_primitive_element radicals)rminpoly_of_elementto_rootr)rrrrr6r6r7to_primitive_elementV s A z$AlgebraicNumber.to_primitive_elementcCsH|jdkrB|jr|j|_n(ddlm}|}|||dd|_|jS)a{ Compute the minimal polynomial for this algebraic number. Explanation =========== Recall that we represent an element $\alpha \in \mathbb{Q}(\theta)$. Our instance attribute ``self.minpoly`` is the minimal polynomial for our primitive element $\theta$. This method computes the minimal polynomial for $\alpha$. NrrTr)rrrZ sympy.polys.numberfields.minpolyrr)rrthetar6r6r7r s   z"AlgebraicNumber.minpoly_of_elementcCsn|jrt|jts|jS|p"|}|j|d}t|dkrD|dS|}|D]}|||rP|SqPdS)a Convert to an :py:class:`~.Expr` that is not an :py:class:`~.AlgebraicNumber`, specifically, either a :py:class:`~.ComplexRootOf`, or, optionally and where possible, an expression in radicals. Parameters ========== radicals : boolean, optional (default=True) If ``True``, then we will try to return the root as an expression in radicals. If that is not possible, we will return a :py:class:`~.ComplexRootOf`. minpoly : :py:class:`~.Poly` If the minimal polynomial for `self` has been pre-computed, it can be passed in order to save time. rrrN) rr@rrrrrjrZ same_root)rrrrrootsrrMr6r6r7r s    zAlgebraicNumber.to_root)NN)N)N)T)TN)rrrrr r is_algebraicr2rr setrrdrrrrhrrrrrrrrrrrrrr r6r6rr7r s4  i    +  Grc@seZdZdZdZddZdS)RationalConstantz Abstract base class for rationals with specific behaviors Derived classes must define class attributes p and q and should probably all be singletons. r6cCs t|Sr1rrrr6r6r7r szRationalConstant.__new__N)rrrrr rr6r6r6r7r src@seZdZdZddZdS)IntegerConstantr6cCs t|Sr1rrr6r6r7r szIntegerConstant.__new__N)rrrr rr6r6r6r7r src@sheZdZdZdZdZdZdZdZdZ dZ dZ ddZ e d d Ze d d Zd dZddZddZdS)raThe number zero. Zero is a singleton, and can be accessed by ``S.Zero`` Examples ======== >>> from sympy import S, Integer >>> Integer(0) is S.Zero True >>> 1/S.Zero zoo References ========== .. [1] https://en.wikipedia.org/wiki/Zero rrFTr6cCsdSrr6rr6r6r7rx szZero.__getnewargs__cCstjSr1rr6r6r6r7rO sz Zero.__abs__cCstjSr1rr6r6r6r7r> sz Zero.__neg__cCsd|jr |S|jrtjS|jdkr&tjS|jr2tjS|\}}|j rNtj|S|tjk r`||SdSNF) rIrr rJrgrrrrr)rrZrtermsr6r6r7rL s    zZero._eval_powercGs|Sr1r6rrr6r6r7r# szZero._eval_ordercCsdSrr6rr6r6r7r=' sz Zero.__bool__N)rrrrrdrerrrr2rXr rx staticmethodrOr>rLrr=r6r6r6r7r s"  r) metaclassc@sbeZdZdZdZdZdZdZdZddZ e ddZ e d d Z d d Z d dZe dddZdS)ra The number one. One is a singleton, and can be accessed by ``S.One``. Examples ======== >>> from sympy import S, Integer >>> Integer(1) is S.One True References ========== .. [1] https://en.wikipedia.org/wiki/1_%28number%29 Trr6cCsdSrr6rr6r6r7rxD szOne.__getnewargs__cCstjSr1rr6r6r6r7rOG sz One.__abs__cCstjSr1)r rr6r6r6r7r>K sz One.__neg__cCs|Sr1r6rrZr6r6r7rLO szOne._eval_powercGsdSr1r6rr6r6r7rR szOne._eval_orderNFcCs|r tjSiSdSr1r)rrrrrrr6r6r7rU sz One.factors)NTFFFF)rrrrr2rrdrer rxrrOr>rLrrr6r6r6r7r+ s$  rc@sHeZdZdZdZdZdZdZddZe dd Z e d d Z d d Z dS)ra]The number negative one. NegativeOne is a singleton, and can be accessed by ``S.NegativeOne``. Examples ======== >>> from sympy import S, Integer >>> Integer(-1) is S.NegativeOne True See Also ======== One References ========== .. [1] https://en.wikipedia.org/wiki/%E2%88%921_%28number%29 Trbrr6cCsdSrr6rr6r6r7rx| szNegativeOne.__getnewargs__cCstjSr1rr6r6r6r7rO szNegativeOne.__abs__cCstjSr1rr6r6r6r7r> szNegativeOne.__neg__cCs|jr tjS|jrtjSt|trt|tr8td|S|tjkrHtjS|tj tj fkr^tjS|tj krntj St|t r|jdkrtj t|jSt|j|j\}}|r|||t ||jSdS)Ngr/)is_oddr rr|rr@rrDrrrrrrMrorerkrdr)rrZr5rr6r6r7rL s(       zNegativeOne._eval_powerN) rrrrr2rdrer rxrrOr>rLr6r6r6r7r^ s  rc@s4eZdZdZdZdZdZdZddZe dd Z d S) rraThe rational number 1/2. Half is a singleton, and can be accessed by ``S.Half``. Examples ======== >>> from sympy import S, Rational >>> Rational(1, 2) is S.Half True References ========== .. [1] https://en.wikipedia.org/wiki/One_half Trr/r6cCsdSrr6rr6r6r7rx szHalf.__getnewargs__cCstjSr1)r rrr6r6r6r7rO sz Half.__abs__N) rrrrr2rdrer rxrrOr6r6r6r7rr srrcs@eZdZdZdZdZdZdZdZdZ dZ dZ dZ ddZ ddZd d Zd/d d Zd0ddZededdZeZededdZededdZededdZeZededdZddZddZdd Zd!d"Zfd#d$Zd%d&Z d'd(Z!e"j#Z#e"j$Z$e"j%Z%e"j&Z&eded)d*Z'e'Z(d+d,Z)d-d.Z*Z+S)1raPositive infinite quantity. Explanation =========== In real analysis the symbol `\infty` denotes an unbounded limit: `x\to\infty` means that `x` grows without bound. Infinity is often used not only to define a limit but as a value in the affinely extended real number system. Points labeled `+\infty` and `-\infty` can be added to the topological space of the real numbers, producing the two-point compactification of the real numbers. Adding algebraic properties to this gives us the extended real numbers. Infinity is a singleton, and can be accessed by ``S.Infinity``, or can be imported as ``oo``. Examples ======== >>> from sympy import oo, exp, limit, Symbol >>> 1 + oo oo >>> 42/oo 0 >>> x = Symbol('x') >>> limit(exp(x), x, oo) oo See Also ======== NegativeInfinity, NaN References ========== .. [1] https://en.wikipedia.org/wiki/Infinity TFr6cCs t|Sr1rrr6r6r7r szInfinity.__new__cCsdS)Nz\inftyr6rprinterr6r6r7_latex szInfinity._latexcCs||kr |SdSr1r6rr6r6r7r szInfinity._eval_subsNcCstdSNrrDrr6r6r7r szInfinity._eval_evalfcKs ||Sr1rrrWoptionsr6r6r7rY szInfinity.evalfrcCs6t|tr*tjr*|tjtjfkr&tjS|St||Sr1)r@rr.rr rrrrr6r6r7r s zInfinity.__add__cCs6t|tr*tjr*|tjtjfkr&tjS|St||Sr1)r@rr.rr rrrrr6r6r7r s zInfinity.__sub__cCs | |Sr1rrr6r6r7rz szInfinity.__rsub__cCsBt|tr6tjr6|js |tjkr&tjS|jr0|StjSt ||Sr1) r@rr.rrr rrIrrrr6r6r7r szInfinity.__mul__cCsPt|trDtjrD|tjks.|tjks.|tjkr4tjS|jr>|StjSt ||Sr1 r@rr.rr rrrZis_extended_nonnegativerrr6r6r7r" s zInfinity.__truediv__cCstjSr1r rrr6r6r7rO. szInfinity.__abs__cCstjSr1)r rrr6r6r7r>1 szInfinity.__neg__cCs|jr tjS|jrtjS|tjkr(tjS|tjkr8tjS|jdkr|jrddl m }||}|j rhtjS|j rttjS|j rtjS||SdS)a ``expt`` is symbolic object but not equal to 0 or 1. ================ ======= ============================== Expression Result Notes ================ ======= ============================== ``oo ** nan`` ``nan`` ``oo ** -p`` ``0`` ``p`` is number, ``oo`` ================ ======= ============================== See Also ======== Pow NaN NegativeInfinity Fr)rNN)rIr rrrrrJrgr2rrNrrrrY)rrZrNZ expt_realr6r6r7rL4 s$   zInfinity._eval_powercCstjSr1)rr$rr6r6r7rZ szInfinity._as_mpf_valcs tSr1rrrr6r7r] szInfinity.__hash__cCs|tjkp|tdkSrr rrrr6r6r7r` szInfinity.__eq__cCs|tjk o|tdkSrr rr6r6r7rc szInfinity.__ne__cCst|tstStjSr1r@rrr rrr6r6r7rDk s zInfinity.__mod__cCs|Sr1r6rr6r6r7rs szInfinity.floorcCs|Sr1r6rr6r6r7rv szInfinity.ceiling)N)N),rrrrrr2 is_complexrgrrXrIrr rrrrrYrrrrrrzrrrrOr>rLrrrrrrrrrrDrFrrr r6r6rr7r sV(       &  rcsHeZdZdZdZdZdZdZdZdZ dZ dZ dZ ddZ ddZd d Zd1d d Zd2ddZededdZeZededdZededdZededdZeZededdZddZddZdd Zd!d"Zfd#d$Zd%d&Z d'd(Z!e"j#Z#e"j$Z$e"j%Z%e"j&Z&eded)d*Z'e'Z(d+d,Z)d-d.Z*d/d0Z+Z,S)3rzNegative infinite quantity. NegativeInfinity is a singleton, and can be accessed by ``S.NegativeInfinity``. See Also ======== Infinity TFr6cCs t|Sr1rrr6r6r7r szNegativeInfinity.__new__cCsdS)Nz-\inftyr6rr6r6r7r szNegativeInfinity._latexcCs||kr |SdSr1r6rr6r6r7r szNegativeInfinity._eval_subsNcCstdSNrrrr6r6r7r szNegativeInfinity._eval_evalfcKs ||Sr1rrr6r6r7rY szNegativeInfinity.evalfrcCs6t|tr*tjr*|tjtjfkr&tjS|St||Sr1)r@rr.rr rrrrr6r6r7r s zNegativeInfinity.__add__cCs6t|tr*tjr*|tjtjfkr&tjS|St||Sr1)r@rr.rr rrrrr6r6r7r s zNegativeInfinity.__sub__cCs | |Sr1r rr6r6r7rz szNegativeInfinity.__rsub__cCsBt|tr6tjr6|js |tjkr&tjS|jr0|StjSt ||Sr1) r@rr.rrr rrIrrrr6r6r7r szNegativeInfinity.__mul__cCsPt|trDtjrD|tjks.|tjks.|tjkr4tjS|jr>|StjSt ||Sr1r rr6r6r7r s zNegativeInfinity.__truediv__cCstjSr1r rr6r6r7rO szNegativeInfinity.__abs__cCstjSr1r rr6r6r7r> szNegativeInfinity.__neg__cCs|jr|tjks$|tjks$|tjkr*tjSt|trL|jrL|jrFtjStjStj|}tj |}|dkrr|j rr|S|tj kr|j r|j stj S||SdS)a^ ``expt`` is symbolic object but not equal to 0 or 1. ================ ======= ============================== Expression Result Notes ================ ======= ============================== ``(-oo) ** nan`` ``nan`` ``(-oo) ** oo`` ``nan`` ``(-oo) ** -oo`` ``nan`` ``(-oo) ** e`` ``oo`` ``e`` is positive even integer ``(-oo) ** o`` ``-oo`` ``o`` is positive odd integer ================ ======= ============================== See Also ======== Infinity Pow NaN rN) r2r rrrr@rkrIrrrgrJr)rrZZinf_partZs_partr6r6r7rL s,    zNegativeInfinity._eval_powercCstjSr1)rr%rr6r6r7rszNegativeInfinity._as_mpf_valcs tSr1rrrr6r7rszNegativeInfinity.__hash__cCs|tjkp|tdkSrr rrrr6r6r7rszNegativeInfinity.__eq__cCs|tjk o|tdkSrrrr6r6r7r szNegativeInfinity.__ne__cCst|tstStjSr1rrr6r6r7rDs zNegativeInfinity.__mod__cCs|Sr1r6rr6r6r7rszNegativeInfinity.floorcCs|Sr1r6rr6r6r7rszNegativeInfinity.ceilingcCstjdtjdiSrV)r rrrr6r6r7as_powers_dictszNegativeInfinity.as_powers_dict)N)N)-rrrrrgrrrrXrr2rr rrrrrYrrrrrrzrrrrOr>rLrrrrrrrrrrDrFrrrr r6r6rr7r| sX        +  rcseZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZdZddZdd Zd d Zed ed dZed eddZed eddZed eddZddZddZddZfddZddZ dd Z!e"j#Z#e"j$Z$e"j%Z%e"j&Z&Z'S)!ra. Not a Number. Explanation =========== This serves as a place holder for numeric values that are indeterminate. Most operations on NaN, produce another NaN. Most indeterminate forms, such as ``0/0`` or ``oo - oo` produce NaN. Two exceptions are ``0**0`` and ``oo**0``, which all produce ``1`` (this is consistent with Python's float). NaN is loosely related to floating point nan, which is defined in the IEEE 754 floating point standard, and corresponds to the Python ``float('nan')``. Differences are noted below. NaN is mathematically not equal to anything else, even NaN itself. This explains the initially counter-intuitive results with ``Eq`` and ``==`` in the examples below. NaN is not comparable so inequalities raise a TypeError. This is in contrast with floating point nan where all inequalities are false. NaN is a singleton, and can be accessed by ``S.NaN``, or can be imported as ``nan``. Examples ======== >>> from sympy import nan, S, oo, Eq >>> nan is S.NaN True >>> oo - oo nan >>> nan + 1 nan >>> Eq(nan, nan) # mathematical equality False >>> nan == nan # structural equality True References ========== .. [1] https://en.wikipedia.org/wiki/NaN TNFr6cCs t|Sr1rrr6r6r7rdsz NaN.__new__cCsdS)Nz \text{NaN}r6rr6r6r7rgsz NaN._latexcCs|Sr1r6rr6r6r7r>jsz NaN.__neg__rcCs|Sr1r6rr6r6r7rmsz NaN.__add__cCs|Sr1r6rr6r6r7rqsz NaN.__sub__cCs|Sr1r6rr6r6r7rusz NaN.__mul__cCs|Sr1r6rr6r6r7ryszNaN.__truediv__cCs|Sr1r6rr6r6r7r}sz NaN.floorcCs|Sr1r6rr6r6r7rsz NaN.ceilingcCstSr1)r(rr6r6r7rszNaN._as_mpf_valcs tSr1rrrr6r7rsz NaN.__hash__cCs |tjkSr1r rrr6r6r7rsz NaN.__eq__cCs |tjk Sr1rrr6r6r7rsz NaN.__ne__)(rrrrrrgrfreris_transcendentalrrXrgrrrrr2r rrr>rrrrrrrrrrrrrrrrrr r6r6rr7r#sJ/     rcCsdSrr6)rLrMr6r6r7 _eval_is_eqsrc@speZdZdZdZdZdZdZdZdZ e Z dZ ddZ ddZed d Zd d Zd dZeddZddZdS)rJaComplex infinity. Explanation =========== In complex analysis the symbol `\tilde\infty`, called "complex infinity", represents a quantity with infinite magnitude, but undetermined complex phase. ComplexInfinity is a singleton, and can be accessed by ``S.ComplexInfinity``, or can be imported as ``zoo``. Examples ======== >>> from sympy import zoo >>> zoo + 42 zoo >>> 42/zoo 0 >>> zoo + zoo nan >>> zoo*zoo zoo See Also ======== Infinity TFr6cCs t|Sr1rrr6r6r7rszComplexInfinity.__new__cCsdS)Nz\tilde{\infty}r6rr6r6r7rszComplexInfinity._latexcCstjSr1r r6r6r6r7rOszComplexInfinity.__abs__cCs|Sr1r6rr6r6r7rszComplexInfinity.floorcCs|Sr1r6rr6r6r7rszComplexInfinity.ceilingcCstjSr1)r rJr6r6r6r7r>szComplexInfinity.__neg__cCs<|tjkrtjSt|tr8|jr&tjS|jr2tjStjSdSr1)r rJrr@rrrrrr6r6r7rLs  zComplexInfinity._eval_powerN)rrrrrrr2rrrgrr r rrrrOrrr>rLr6r6r6r7rJs$  rJcsteZdZdZdZdZdZdZeZ ddZ ddZ ddZ d d Z d d Zd dZddZddZfddZZS)r\Tr6cCs t|Sr1rrr6r6r7rszNumberSymbol.__new__cCsdS)z Return an interval with number_cls endpoints that contains the value of NumberSymbol. If not implemented, then return None. Nr6rZ number_clsr6r6r7 approximationszNumberSymbol.approximationcCst|||Sr1rrr6r6r7rszNumberSymbol._eval_evalfcCsFz t|}Wntk r$tYSX||kr2dS|jrB|jrBdSdSr1)r rrrrSrr6r6r7rs   zNumberSymbol.__eq__cCs ||k Sr1r6rr6r6r7rszNumberSymbol.__ne__cCs||krtjSt||Sr1)r rrrrr6r6r7rszNumberSymbol.__le__cCs||krtjSt||Sr1)r rrrrr6r6r7rszNumberSymbol.__ge__cCstdSr1)rrr6r6r7rPszNumberSymbol.__int__cs tSr1rrrr6r7r"szNumberSymbol.__hash__)rrrrrgr2r rRrr rrrrrrrrPrr r6r6rr7r\s r\c@s|eZdZdZdZdZdZdZdZdZ dZ dZ ddZ e ddZd d Zd d Zd dZddZddZddZddZdS)Exp1a:The `e` constant. Explanation =========== The transcendental number `e = 2.718281828\ldots` is the base of the natural logarithm and of the exponential function, `e = \exp(1)`. Sometimes called Euler's number or Napier's constant. Exp1 is a singleton, and can be accessed by ``S.Exp1``, or can be imported as ``E``. Examples ======== >>> from sympy import exp, log, E >>> E is exp(1) True >>> log(E) 1 References ========== .. [1] https://en.wikipedia.org/wiki/E_%28mathematical_constant%29 TFr6cCsdS)Nrsr6rr6r6r7rLsz Exp1._latexcCstjSr1)r rr6r6r6r7rOOsz Exp1.__abs__cCsdSrr6rr6r6r7rPSsz Exp1.__int__cCst|Sr1)r!rr6r6r7rVszExp1._as_mpf_valcCs(t|trtdtdfSt|tr$dS)Nr/r issubclassrkrorr6r6r7approximation_intervalYs  zExp1.approximation_intervalcCs(tjr||Sddlm}||SdS)Nr)exp)r.Z exp_is_pow_eval_power_exp_is_pow&sympy.functions.elementary.exponentialr)rrZrr6r6r7rL_s  zExp1._eval_powercCsb|jr"|tkrtS|t kr"tjSddlm}t||rB|jdS|jst t}||| fkrdt S| t t }|rd|j r|jrtjS|jrtjS|tjjrt S|tjjrt Sn@|jr|d}|dkr|d8}||krtj|tjtjS|\}}|tt fkrdS|gd}}t|D]J} t| |rb|dkrZ| jd}ndSn| jrv|| ndSq4|r|t|SdS|jrNg} g} d} |jD]t} | tjkr| | q|| }t|tr|j|kr|j| kr | |jd} n | | n | |q| s2| r^t| t|t| ddSn|j r^|SdS)Nr)logr/rFTrG)!roor rrrr@r~Zis_AddIrrpirr|rrrrrrrPirMrMulZ make_argsrXappendrKbaserrZ is_Matrix)rargrZIoorZncoeffrrZlog_termtermoutaddZ argchangedrLZnewar6r6r7rfsz                      zExp1._eval_power_exp_is_powcKs*ddlm}|ttjdt|tS)Nr)sinr/)(sympy.functions.elementary.trigonometricr+r!r r#)rrr+r6r6r7_eval_rewrite_as_sins zExp1._eval_rewrite_as_sincKs*ddlm}|tt|ttjdS)Nr)cosr/)r,r.r!r r#)rrr.r6r6r7_eval_rewrite_as_coss zExp1._eval_rewrite_as_cosN)rrrrrfrrrSr2rrr rrrOrPrrrLrr-r/r6r6r6r7r&s& Prc@s\eZdZdZdZdZdZdZdZdZ dZ dZ ddZ e ddZd d Zd d Zd dZdS)r#aThe `\pi` constant. Explanation =========== The transcendental number `\pi = 3.141592654\ldots` represents the ratio of a circle's circumference to its diameter, the area of the unit circle, the half-period of trigonometric functions, and many other things in mathematics. Pi is a singleton, and can be accessed by ``S.Pi``, or can be imported as ``pi``. Examples ======== >>> from sympy import S, pi, oo, sin, exp, integrate, Symbol >>> S.Pi pi >>> pi > 3 True >>> pi.is_irrational True >>> x = Symbol('x') >>> sin(x + 2*pi) sin(x) >>> integrate(exp(-x**2), (x, -oo, oo)) sqrt(pi) References ========== .. [1] https://en.wikipedia.org/wiki/Pi TFr6cCsdS)Nz\pir6rr6r6r7rsz Pi._latexcCstjSr1)r r#r6r6r6r7rOsz Pi.__abs__cCsdS)Nrr6rr6r6r7rPsz Pi.__int__cCst|Sr1)r rr6r6r7rszPi._as_mpf_valcCs@t|trtdtdfSt|tr>> from sympy import S >>> S.GoldenRatio > 1 True >>> S.GoldenRatio.expand(func=True) 1/2 + sqrt(5)/2 >>> S.GoldenRatio.is_irrational True References ========== .. [1] https://en.wikipedia.org/wiki/Golden_ratio TFr6cCsdS)Nz\phir6rr6r6r7r,szGoldenRatio._latexcCsdSrVr6rr6r6r7rP/szGoldenRatio.__int__cCs$tt|d| d}t||SNr>)r from_man_expr"r]r.r6r6r7r2szGoldenRatio._as_mpf_valcKs ddlm}tjtj|dS)Nr)sqrtr?)(sympy.functions.elementary.miscellaneousr7r rr)rhintsr7r6r6r7_eval_expand_func7s zGoldenRatio._eval_expand_funccCs&t|trtjtdfSt|tr"dSrrrkr rrorr6r6r7r;s  z"GoldenRatio.approximation_intervalN)rrrrrfrrrSr2rrr rrPrr:r_eval_rewrite_as_sqrtr6r6r6r7r4sr4c@s\eZdZdZdZdZdZdZdZdZ dZ dZ ddZ ddZ d d Zd d Zd dZeZdS)TribonacciConstantaThe tribonacci constant. Explanation =========== The tribonacci numbers are like the Fibonacci numbers, but instead of starting with two predetermined terms, the sequence starts with three predetermined terms and each term afterwards is the sum of the preceding three terms. The tribonacci constant is the ratio toward which adjacent tribonacci numbers tend. It is a root of the polynomial `x^3 - x^2 - x - 1 = 0`, and also satisfies the equation `x + x^{-3} = 2`. TribonacciConstant is a singleton, and can be accessed by ``S.TribonacciConstant``. Examples ======== >>> from sympy import S >>> S.TribonacciConstant > 1 True >>> S.TribonacciConstant.expand(func=True) 1/3 + (19 - 3*sqrt(33))**(1/3)/3 + (3*sqrt(33) + 19)**(1/3)/3 >>> S.TribonacciConstant.is_irrational True >>> S.TribonacciConstant.n(20) 1.8392867552141611326 References ========== .. [1] https://en.wikipedia.org/wiki/Generalizations_of_Fibonacci_numbers#Tribonacci_numbers TFr6cCsdS)Nz\text{TribonacciConstant}r6rr6r6r7rsszTribonacciConstant._latexcCsdSrVr6rr6r6r7rPvszTribonacciConstant.__int__cCs"|jdd|d}t||dS)NT)functionrrC)r:rrDr.r6r6r7ryszTribonacciConstant._eval_evalfcKs@ddlm}m}d|dd|d|dd|ddS)Nr)cbrtr7rr!)r8r?r7)rr9r?r7r6r6r7r:}sz$TribonacciConstant._eval_expand_funccCs&t|trtjtdfSt|tr"dSrr;rr6r6r7rs  z)TribonacciConstant.approximation_intervalN)rrrrrfrrrSr2rrr rrPrr:rr<r6r6r6r7r=Ds$r=c@sHeZdZdZdZdZdZdZdZdZ ddZ dd Z d d Z d d Z dS) EulerGammaaThe Euler-Mascheroni constant. Explanation =========== `\gamma = 0.5772157\ldots` (also called Euler's constant) is a mathematical constant recurring in analysis and number theory. It is defined as the limiting difference between the harmonic series and the natural logarithm: .. math:: \gamma = \lim\limits_{n\to\infty} \left(\sum\limits_{k=1}^n\frac{1}{k} - \ln n\right) EulerGamma is a singleton, and can be accessed by ``S.EulerGamma``. Examples ======== >>> from sympy import S >>> S.EulerGamma.is_irrational >>> S.EulerGamma > 0 True >>> S.EulerGamma > 1 False References ========== .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Mascheroni_constant TFNr6cCsdS)Nz\gammar6rr6r6r7rszEulerGamma._latexcCsdSrBr6rr6r6r7rPszEulerGamma.__int__cCs,tj|d}t|| d}t||Sr5)rZlibhyperZ euler_fixedr6r]rrWrr\r6r6r7rszEulerGamma._as_mpf_valcCs6t|trtjtjfSt|tr2tjtdddfSdS)Nrr?r)rrkr rrrorrrr6r6r7rs   z!EulerGamma.approximation_interval)rrrrrfrrrSr2r rrPrrr6r6r6r7rBsrBc@sReZdZdZdZdZdZdZdZdZ ddZ dd Z d d Z dd d Z ddZdS)CatalanaCatalan's constant. Explanation =========== $G = 0.91596559\ldots$ is given by the infinite series .. math:: G = \sum_{k=0}^{\infty} \frac{(-1)^k}{(2k+1)^2} Catalan is a singleton, and can be accessed by ``S.Catalan``. Examples ======== >>> from sympy import S >>> S.Catalan.is_irrational >>> S.Catalan > 0 True >>> S.Catalan > 1 False References ========== .. [1] https://en.wikipedia.org/wiki/Catalan%27s_constant TFNr6cCsdSrBr6rr6r6r7rPszCatalan.__int__cCs*t|d}t|| d}t||Sr5)rZ catalan_fixedr6r]rCr6r6r7rszCatalan._as_mpf_valcCs6t|trtjtjfSt|tr2tdddtjfSdS)N r>r)rrkr rrrorr6r6r7rs   zCatalan.approximation_intervalcCsb|dk s|dk r|Sddlm}ddlm}|dddd}|tj|d|dd|dtjfS) Nrrr)SumrT)integerZ nonnegativer/)rrZsympy.concrete.summationsrFr rr)rZk_symrrrFrr6r6r7_eval_rewrite_as_Sums   zCatalan._eval_rewrite_as_SumcCsdS)NGr6rr6r6r7rszCatalan._latex)NN)rrrrrfrrrSr2r rPrrrHrr6r6r6r7rDs rDc@speZdZdZdZdZdZdZdZdZ e Z dZ ddZ eddZd d Zd d Zd dZddZeddZdS)rMaTThe imaginary unit, `i = \sqrt{-1}`. I is a singleton, and can be accessed by ``S.I``, or can be imported as ``I``. Examples ======== >>> from sympy import I, sqrt >>> sqrt(-1) I >>> I*I -1 >>> 1/I -I References ========== .. [1] https://en.wikipedia.org/wiki/Imaginary_unit TFr6cCs |jdS)NZimaginary_unit_latex)Z _settingsrr6r6r7r&szImaginaryUnit._latexcCstjSr1rr6r6r6r7rO)szImaginaryUnit.__abs__cCs|Sr1r6rr6r6r7r-szImaginaryUnit._eval_evalfcCstj Sr1)r rMrr6r6r7r0szImaginaryUnit._eval_conjugatecCst|trL|d}|dkr tjS|dkr.tjS|dkr (-1)**(r/2) -> exp(r/2*Pi*I) -> sin(Pi*r/2) + cos(Pi*r/2)*I, r is decimal I**0 mod 4 -> 1 I**1 mod 4 -> I I**2 mod 4 -> -1 I**3 mod 4 -> -I rrrr/rFrGN) r@rkr rrMrrorrKr$)rrZr5rr\r6r6r7rL3s  zImaginaryUnit._eval_powercCs tjtjfSr1)r rrrrr6r6r7 as_base_expPszImaginaryUnit.as_base_expcCstdjtdjfS)Nrr)rDrarr6r6r7_mpc_SszImaginaryUnit._mpc_N)rrrrrZ is_imaginaryrgr2rrrr r rrrOrrrLrJrhrKr6r6r6r7rMs$ rMc Cst|}t|}|js$|js$||kS|jr<|jr<|j|jkS|jrL||}}|jsVdS|j\}}}}|j|j}}|r|| }|dkr|dko||kS|dkr|dkrdS|||krdS||>|kS||krdS| }|d|krdSd|>|kSdS)aCompare expressions treating plain floats as rationals. Examples ======== >>> from sympy import S, symbols, Rational, Float >>> from sympy.core.numbers import equal_valued >>> equal_valued(1, 2) False >>> equal_valued(1, 1) True In SymPy expressions with Floats compare unequal to corresponding expressions with rationals: >>> x = symbols('x') >>> x**2 == x**2.0 False However an individual Float compares equal to a Rational: >>> Rational(1, 2) == Float(0.5) True In a future version of SymPy this might change so that Rational and Float compare unequal. This function provides the behavior currently expected of ``==`` so that it could still be used if the behavior of ``==`` were to change in future. >>> equal_valued(1, 1.0) # Float vs Rational True >>> equal_valued(S(1).n(3), S(1).n(5)) # Floats of different precision True Explanation =========== In future SymPy verions Float and Rational might compare unequal and floats with different precisions might compare unequal. In that context a function is needed that can check if a number is equal to 1 or 0 etc. The idea is that instead of testing ``if x == 1:`` if we want to accept floats like ``1.0`` as well then the test can be written as ``if equal_valued(x, 1):`` or ``if equal_valued(x, 2):``. Since this function is intended to be used in situations where one or both operands are expected to be concrete numbers like 1 or 0 the function does not recurse through the args of any compound expression to compare any nested floats. References ========== .. [1] https://github.com/sympy/sympy/pull/20033 FrrN)r rTrarrdrer) rrrXrYrrOrdreZneg_expr6r6r7rH[s85     rHcCsdSrr6rr6r6r7rscCst|j|jdSrV)rorprqrxr6r6r7sympify_fractionssrLcCs tt|Sr1)rkrJrr6r6r7 sympify_mpzsrNcCstt|jt|jSr1)rorJrprqrMr6r6r7 sympify_mpqsrOcCs|j\}}t||dSrV)Z_mpq_ro)rrdrer6r6r7sympify_mpmath_mpqs rPcCst||jjSr1)rZ _from_mpmathrrWrMr6r6r7sympify_mpmathsrQcCs(ttt|j|jf\}}|tj|Sr1)r!maprrealimagr rM)rLrSrTr6r6r7sympify_complexsrU)rKr)r$)rcCs4tjttjttjttjtdSr1)rrregisterRealrDrorrkr6r6r6r7_register_classess   rX)N)F) __future__rrrrnr}rNregexr functoolsr containersrrrrr r r Z singletonr r basicrrrrrYrcacherrZ decoratorsrZlogicrr rZsympy.external.gmpyrrrZsympy.multipledispatchrrcZ mpmath.libmpZlibmprrrrUrSrrr r!r"Z mpmath.ctx_mpr#Zmpmath.libmp.libmpfr$r)r%r*r&r(r'r(rTr)r*Zsympy.utilities.miscr+r,r- parametersr.rZ_LOG2r<r]r_r`rfrtcompilervrzrr|Zigcd2rrrrrrDrrZ RealNumberrorkrJrrrrrrrrrr rrrrrJZzoor\rEr#r"r4r=rBrDrMr!rHrLrorNrOrZmpzZmpqrPrrQrUcomplexrrKrmulr$identityr*rrXZ_illegalr6r6r6r7s             $   m    (.A.q9K  D3@ <(s M9A?F;?Ta