wgCddlmZddlZddlZddlZddlZddlmZddlm Z m Z mZm Z m Z m Z ddlmZmZddlmZddlmZmZdd lmZdd lmZmZdd lmZdd lmZmZm Z m!Z!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,ddl-Z-ddl.m/Z0ddl.m1Z1m2Z3ddl4m5Z5ddl.m6Z6m7Z7m8Z8m9Z9ddl:m;Z;ddlm?Z@mAZBmCZCmDZEmFZFmGZGddlHmIZIddlJmKZKejdZMdadZNdZOddiZPdbdZQdZRdZSeTjeVjd ZXd!ZYGd"d#eZZGd$d%eZZ[e[xe e\<e ej<e[Z^Gd&d'eZZ_Gd(d)e_Z`e`e ea<Gd*d+eZbGd,d-e_ZcGd.d/e`ZdGd0d1ede2ZeGd3d4ede2ZfGd5d6ede2ZgGd7d8ece2ZhGd9d:eZe2ZiejZjGd;deZe2ZlejZme,eled?ZnGd@dAee2ZoejZpGdBdCeZqGdDdEeqe2ZrejZsGdFdGeqe2ZtejZuGdHdIeqe2ZvGdJdKeqe2ZwGdLdMeqe2ZxGdNdOeqe2ZyGdPdQee2ZzejZ{dRZ|dSZ}dcdTZ~e,eeZdUZndVZee ej<e)?dWZdXZee ee)jd<ee ee)j dd<e*?dYZdZZee ee*jd<ee ee*jdd<d[Zee e;<d\Zee e<dd]lmZdd^lmZefe_dd_lmZeee_d`ZeejejejejfZy)d) annotationsN)Tuple) SympifyError_sympy_convertersympify_convert_numpy_types_sympify_is_numpy_instance)S Singleton)Basic)Expr AtomicExpr) pure_complex)cacheit clear_cache) _sympifyit) num_digitsigcdilcm mod_inverseinteger_nthroot) fuzzy_not) NumberKind) SYMPY_INTSgmpyflint)dispatch)bitcount round_nearestMPZ)mpf_powmpf_pimpf_e phi_fixed) mpnumeric)finffninffnanfzero _normalize prec_to_dps dps_to_prec)debug)global_parametersc Dt|tr&t|ds tdt||k(S|s||}}|sy|s||}}|dk(rt|t|k(S|t |t |}}t d||fDs td|j t}|j t}|s|s||k(StdD]U}t|d}|r|r9|jttd|D}t|d}n ||}}||}}Wt|} | s9|r7|jttd |D}t|d} r(| r&|d s| d rt d t|| DSd tt|jt|d |jz}tt!||z |zdkSt!||z } t!|} |r | d kDr| | z |kS| |kS)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)or_realz$when z2 is a str z1 must be a Numberc34K|]}|jywN) is_number.0is W/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/core/numbers.py zcomp..qs3qq{{3zexpecting 2 numbersr2c34K|]}|jywr7_precr9s r<r=zcomp..}s/DA/Dr>c34K|]}|jywr7r@r9s r<r=zcomp..s'rc3:K|]\}}t||ywr7)comp)r:r;js r<r=zcomp..s>$!Q41:>s rA) isinstancestrr ValueErrorrallatomsFloatrangenr.minziprAgetattrintabs) z1z2tolabfafb_cacbdiffaz1s r<rDrD&sz"cB-CD D2w"} RB  21 "9q6SV# # ;1:wqzqA3QF33 !677BBbAv 1X $!!T2CC C/D/D,D EF)!T:!#RB !1 $aB"CC C'<'<$<=>!!T2bber!u>#b"+>>>k#aggwq'177/K"LMMCs1q5z#~&!+ + rBwrac6|jstd|z|j\}}}t|}|dk\rt t |}||fSd|z}t dtt|D}t||zd| z}||fS)z3Convert an ordinary decimal instance to a Rational.zdec must be finite, got %s.rrtc32K|]\}}|d|zzyw)rFN)r:r;dis r<r=z,_decimal_to_Rational_prec..s=UQ2q5=srF) is_finite TypeErroras_tuplelenIntegerrSsum enumeratereversedRational)decsdergrls r<_decimal_to_Rational_precrs ==?5;<<llnGAq! q6DAv SX  t8O!G =i &<= = ac2r6 " t8Ora 1234567890c|jd}t|dkDryt|dk(r'|\}}|jtdr|dd}|sy|d}}|jd}t|dkDryt|dk(r|\}}n|d}}|s|sy|r |d dvr|dd}|sd}|xsd}|||fD]2}|jd D]}|r|j t sy4y ) aqreturn True if s is space-trimmed number literal else False Python allows underscore as digit separators: there must be a digit on each side. So neither a leading underscore nor a double underscore are valid as part of a number. A number does not have to precede the decimal point, but there must be a digit before the optional "e" or "E" that begins the signs exponent of the number which must be an integer, perhaps with underscore separators. SymPy allows space as a separator; if the calling routine replaces them with underscores then the same semantics will be enforced for them as for underscores: there can only be 1 *between* digits. We don't check for error from float(s) because we don't know whether s is malicious or not. A regex for this could maybe be written but will it be understood by most who read it? rr2Fz+-rN1.rr\T)splitr startswithtuple translate_dig)rpartsmrr;frOgs r<_literal_floatrs( GGCLE 5zA~ 5zQ1 <<d $!"A#1 GGCLE 5zA~ Uq1#1 QQqTT\ abE  SAAY A D)  raceZdZdZdZdZdZdZdZe Z dZ dZ dZ dZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZedZed,dZede dZ!ede dZ"ede dZ#ede dZ$dZ%dZ&dZ'dZ(d Z)d!Z*fd"Z+d#Z,dd$d%Z-d&Z.d-d'Z/d-d(Z0d)Z1d*Z2d+Z3xZ4S).NumberaRepresents 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 Tr|rtct|dk(r|d}t|tr|St|tr t |St|t rt|dk(rt |St|ttjtjfr t|St|tr|j}|dk(rtj S|dk(rtj"S|dk(rtj"S|dk(rtj$St'|}t|tr|St)d|zd }t+|t-|j.z) Nrrr2naninf+inf-infz$String "%s" does not denote a Numberz ! cE6::w? @:  c3 99;Du}uu zz!zz!)))#,C#v&  !G#!MNNLd3i00011rac,t|jSr7)boolis_extended_negativeselfs r<could_extract_minus_signzNumber.could_extract_minus_signZsD--..racZddlm}t|ddr t||S|||g|i|S)Nr)invertr8T)sympy.polys.polytoolsrrRr)rothergensargsrs r<rz Number.invert]s50 5+t ,tU+ +dE1D1D11racddlm} t|}|jstj ||fvr tj tj fS |s td|jr2|jr&tt|j|jSt|tr|t|z }n||z }|j rg|dk\r t#|n t#|dz }|||zz }|t|k(r|dz }d}t|tst|tr)t|}n|r||||k(rdnd}|r|n|}t||S#t $r tcYSwxYw)Nr)rhzmodulo by zerorrt)$sympy.functions.elementary.complexesrhr is_infiniter rrNotImplementedZeroDivisionError is_IntegerrdivmodrvrHrMrr~rS)rrrhratwrs r< __divmod__zNumber.__divmod__csD= "5ME155T5M#9quu~%$:#$45 5 ??u//&12 2 u %x&Cu*C ??1HC#c(Q,AuQwAE%L Q$&*UE*B!H$t*U ";"AAQ{+ "! ! "sA EE10E1c\ t|}t||S#t$r tcYSwxYwr7)rrrrrrs r< __rdivmod__zNumber.__rdivmod__s6 "5MEeT"" "! ! "s ++cFtd|jjz)z7Evaluation of mpf tuple accurate to at least prec bits.z%s needs ._as_mpf_val() methodNotImplementedError __class__rrrgs r< _as_mpf_valzNumber._as_mpf_vals$!"B ^^ $ $#&' 'racLtj|j||Sr7rM_newrrs r< _eval_evalfzNumber._eval_evalfzz$**40$77racTt||j}|j||fSr7)maxrArrs r< _as_mpf_opzNumber._as_mpf_ops(4$%t++racJtj|jdS)N5)mlibto_floatrrs r< __float__zNumber.__float__s}}T--b122racFtd|jjz)Nz%s needs .floor() methodrrs r<floorz Number.floors$!"< ^^ $ $#&' 'racFtd|jjz)Nz%s needs .ceiling() methodrrs r<ceilingzNumber.ceilings$!"> ^^ $ $#&' 'rac"|jSr7rrs r< __floor__zNumber.__floor__zz|rac"|jSr7rrs r<__ceil__zNumber.__ceil__||~rac|Sr7r|rs r<_eval_conjugatezNumber._eval_conjugate rac<ddlm}|tjg|S)Nr)Order)sympy.series.orderrr One)rsymbolsrs r< _eval_orderzNumber._eval_orders,QUU%W%%rac|| k(r| S|Sr7r|roldnews r< _eval_subszNumber._eval_subss 4%<4K racy)N)rrrr|rs r< class_keyzNumber.class_keysrac*|jdd|fS)N)rr|r|)r)rorders r<sort_keyzNumber.sort_keys~~"d22rarc:t|trvtjrf|tj urtj S|tj urtj S|tjurtjStj||Sr7) rHrr1evaluater rrrr__add__rs r<rzNumber.__add__sl eV $):)C)C~uu !**$zz!!,,,)))!!$..rac:t|trvtjrf|tj urtj S|tj urtjS|tjurtj Stj||Sr7) rHrr1rr rrrr__sub__rs r<rzNumber.__sub__sl eV $):)C)C~uu !**$)))!,,,zz!!!$..racFt|trtjr|tj urtj S|tj urH|jrtj S|jrtj StjS|tjur^|jrtj S|jrtjStj St|trtStj||Sr7)rHrr1rr rris_zero is_positiverrrr__mul__rs r<rzNumber.__mul__s eV $):)C)C~uu !**$<<55L%%::%---!,,,<<55L%%---::% u %! !!!$..ract|trdtjrT|tj urtj S|tj tjfvrtjStj||Sr7) rHrr1rr rrrZeror __truediv__rs r<rzNumber.__truediv__s\ eV $):)C)C~uu 1::q'9'9::vv %%dE22racFtd|jjz)Nz%s needs .__eq__() methodrrs r<__eq__z Number.__eq__$!"= ^^ $ $#&' 'racFtd|jjz)Nz%s needs .__ne__() methodrrs r<__ne__z Number.__ne__r rac t|}td|jj z#t$rtd|d|wxYw)NInvalid comparison z < z%s needs .__lt__() methodr rrrrrrs r<__lt__z Number.__lt__sX JUOE""= ^^ $ $#&' ' JD%HI I J /A c t|}td|jj z#t$rtd|d|wxYw)Nrz <= z%s needs .__le__() methodrrs r<__le__z Number.__le__sX KUOE""= ^^ $ $#&' ' KT5IJ J Krc t|}t|j|S#t$rtd|d|wxYw)Nrz > )r rrrrs r<__gt__z Number.__gt__sK JUOE%%d++ JD%HI I J 'Ac t|}t|j|S#t$rtd|d|wxYw)Nrz >= )r rrrrs r<__ge__z Number.__ge__sK KUOE%%d++ KT5IJ J Krc t|Sr7super__hash__rrs r<rzNumber.__hash__w!!racy)NTr|)rwrtflagss r< is_constantzNumber.is_constantra)rationalc|js|s|dfS|jrtj| ffStj|ffSNr|) is_Rational is_negativer NegativeOner)rr%depskwargss r< as_coeff_mulzNumber.as_coeff_mulsB   88O   ==D5(* *uutg~racH|jr|dfStj|ffSr')r(r r)rr+s r< as_coeff_addzNumber.as_coeff_add$s$   8OvvwracN|s|tjfStj|fSz1Efficiently extract the coefficient of a product.r rrr%s r< as_coeff_MulzNumber.as_coeff_Mul*s!; uud{racN|s|tjfStj|fSz3Efficiently extract the coefficient of a summation.r rr3s r< as_coeff_AddzNumber.as_coeff_Add0s!< vvt|rac ddlm}|||S)z#Compute GCD of `self` and `other`. r)gcd)rr:)rrr:s r<r:z Number.gcd6-4rac ddlm}|||S)z#Compute LCM of `self` and `other`. r)lcm)rr=)rrr=s r<r=z Number.lcm;r;rac ddlm}|||S)z1Compute GCD and cofactors of `self` and `other`. r) cofactors)rr?)rrr?s r<r?zNumber.cofactors@s3u%%rar7F)5r __module__ __qualname____doc__is_commutativer8 is_Number __slots__rArkindrrrrrrrrrrrrrrrr classmethodrrrrrrrrrr r rrrrrr#r-r/r4r8r:r=r? __classcell__rs@r<rrs^6NIII E D2</2 <#' 8,3''&   3 3(/)/(/)/(/)/,(3)3'''',,",0     &rarceZdZUdZdZded<dZdZdZdZ dZ dZ e jejdZd1dZed2d Zd Zd Zd Zd ZdZdZedZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'e(de)dZ*e(de)dZ+e(de)d Z,e(de)d!Z-e(de)d"Z.e(de)d#Z/d$Z0d%Z1d&Z2d'Z3d(Z4d)Z5d*Z6d+Z7d,Z8d-Z9d.Z:d3d/Z;d0Z>> 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. rsrAztuple[int, int, int, int]rsNTz-+_.c  | | tdt|tr|jx}}|j ddj }|j drt|dkDrd|z}n|j drt|dkDr d |ddz}n|d vrtjS|d k(rtjS|d k(rtjSt|smtd |zt|tr |dk(rd}nFt|tr|tdk(rtjSt|tr|td k(rtjSt|tr%tj|rtjSt|t t"fr t|}n|tjur|S|tjur|S|tjur|St%|r t'|}n@t|t(j*r&|||j,j.}|j0}||d}t|t2r|St|tr t5j6|}d|v}t9|\}}|j:r|rt=|t?|}t=d|}tA|}n|dk(r||w|dk(rrt|ts td t5j6|}d|v}t9|\}}|j:r#|r!t=|t?|}tA|} ||dk(r tA|}tE|}t|trtGjH||tJ}nUt|trtGjL||tJ}n(t|t4j6r|jOr&tGjLt||tJ}n|jQrtjS|jSr%|dkDrtjStjStdt|zt|tTrt|dvrt|dtrgtW|}|djYdr |ddd|d<|dj dr |ddd|d<t[|dd|d<tU|}nt|dk(rt2j]||St_|ddv|ddk\t_d|Dfstd|t2j]|d|d|dta|df|St|tbtdfr|jg|}n!t)j*||j0}|j]||d S#t4jB$rYwxYw#t4jB$rtd|zwxYw)!Nz=Both decimal and binary precision supplied. Supply only one.  r\rr0z-.r2z-0.)rrrrzstring-float not recognized: %srrr5z^The null string can only be used when the number to Float is passed as a string or an integer.z*string-float not recognized by Decimal: %szunexpected decimal value %s)Lrt0xrR)rrc3JK|]}t|ttfvywr7)rrSr9s r<r=z Float.__new__..sC!QC: 5Cs!#zmalformed mpf: )rgF)zero)4rJrHrIstripreplacerrrr rrrrrmathisnanrrr r rurfcontextrgrsrMrrrrrrr/InvalidOperationrSr from_floatrefrom_strr~is_nanrrlistendswithr#rrKr r NumberSymbolr)rnumdps precision_numNumisintrss r<rz Float.__new__sz ?y412 2 c3  $D3++c3'--/C~~c"s3x!|Ci%#c(Q,c!"go'zz!)))uu #C( !BT!IJJ U #qC U #uU|(;::  U #uV}(<%% % U # 355L j'2 3c(C AJJ J A&& &J AEE\J  $&s+C VZZ ( ; # 0 0I))C ;9,C#u% #s# 1!//#.C sNE8=HC~~%"#z#7b#,C +C 0I "_ 0AcRic3' "KLL 1ooc*34S9S>>ec:c?3C +C 0I   R#C(I N c5 !OOCC8E S !MM#y#6E W__ -}} c#h 3?uu "7::%))) !>S!IJJ U #CF(:#a&#&3iq6??3' VCR[CF q6$$T* VABZCFSVRAc s8q= ::c955Ff,FaKCsCC  ))EFF!::QQQ#a&1AB!##fl3 4OOI.EJJs399Exxyux55y//"++ U !MPS!STT UsX X0X-,X-0"Yc,|r|tk(rtjS|tk(rtjS|t k(rtj S|tk(rtjStj|}t|||_ ||_ |Sr7)r,r r_mpf_nanr_mpf_infr _mpf_ninfrrrrmrsrA)rrsrArWrs r<rz Float._newsu EUN66M h 55L h ::  i %% %ll3UE*   racn|j\}}}}|t|dd||f}d|ji}|f|fS)Nr2rf)rshexrA)rrhriexprkargr,s r<__getnewargs_ex__zFloat.__getnewargs_ex__sG!ZZc3SXab\3+tzz*rac2|j|jfSr7rLrs r<_hashable_contentzFloat._hashable_contents DJJ''rac tttjtj|j |j Sr7)rrSrto_int mpf_floorrsrArs r<rz Float.floors7s4;; NN4::tzz 2456 6rac tttjtj|j |j Sr7)rrSrrvmpf_ceilrsrArs r<rz Float.ceilings7s4;; MM$**djj 1345 5rac"|jSr7rrs r<rzFloat.__floor__rrac"|jSr7rrs r<rzFloat.__ceil__rrac@tj|jSr7)rurfrsrs r<rdz Float.numszz$**%%ract|j|}||jk7r%|j|k(rt|j||Sr7)rmrsrAr0rrgrls r<rzFloat._as_mpf_vals< djj$ '   d 2 $**b ! racF|jt||jfSr7)rsrrArs r<rzFloat._as_mpf_opszz3tTZZ000rac6|jttfvryyNFTrsrlrmrs r<_eval_is_finitezFloat._eval_is_finites ::(I. .rac6|jttfvryyNTFrrs r<_eval_is_infinitezFloat._eval_is_infinites ::(I. .racD|jtk(ryt|syyr)rsr, int_valuedrs r<_eval_is_integerzFloat._eval_is_integers! :: $ racR|jttfvry|jdkSNFrrsrmrlrdrs r<_eval_is_negativezFloat._eval_is_negative$ ::)X. .xx!|racR|jttfvry|jdkDSrrrs r<_eval_is_positivezFloat._eval_is_positiverracp|jtk(ry|jtk(ry|jdkSNTFrrrs r<_eval_is_extended_negativez Float._eval_is_extended_negatives. :: " :: !xx!|racp|jtk(ry|jtk(ry|jdkDSr)rsrlrmrdrs r<_eval_is_extended_positivez Float._eval_is_extended_positives. :: ! :: "xx!|rac(|jtk(Sr7rsr,rs r< _eval_is_zerozFloat._eval_is_zerozzU""rac(|jtk7Sr7rrs r<__bool__zFloat.__bool__rrac|s|Stjtj|j|j Sr7)rMrrmpf_negrsrArs r<__neg__z Float.__neg__s,Kzz$,,tzz2DJJ??rarct|trhtjrX|j |j \}}t jtj|j||t|Stj||Sr7) rHrr1rrrArMrrmpf_addrsrerrrrhsrgs r<rz Float.__add__b eV $):)C)C((4IC::dll4::sD#FM M~~dE**ract|trhtjrX|j |j \}}t jtj|j||t|Stj||Sr7) rHrr1rrrArMrrmpf_subrsrerrs r<rz Float.__sub__rract|trhtjrX|j |j \}}t jtj|j||t|Stj||Sr7) rHrr1rrrArMrrmpf_mulrsrerrs r<rz Float.__mul__rrac(t|trm|dk7rhtjrX|j |j \}}t jtj|j||t|Stj||SNr) rHrr1rrrArMrrmpf_divrsrerrs r<rzFloat.__truediv__sj eV $!8I8R8R((4IC::dll4::sD#FM M!!$..ract|trS|jdk7rDtjr4t tj t|||jSt|t rKtjr;||z }t|r+t dt|j|jSt|trhtjrX|j|j\}}t jtj|j||t |Stj ||S)Nrrfr)rHrrxr1rrM__mod__rArrrrrrmpf_modrsre)rrrrrgs r<rz Float.__mod__s eX &577a< exp(r*log(-p)) -> exp(r*(log(p) + I*Pi)) -> -> p**r*(sin(Pi*r) + cos(Pi*r)*I) rrr2FrN) equal_valuedis_extended_positiverr ComplexInfinityrHrrrArMrr mpf_pow_intrsrvrerrxr)Powr* _eval_powerrr$ ComplexResultmpc_powr, ImaginaryUnit)rrjrgmpfselfyreims r<rzFloat._eval_power-s a (( ((((( dF #$(zzzz$$TZZsCTKKD(+FFaKDFFQJ43C3C1==$?E;;t,--4JD$jjG 9GT45zz!T** $%% 9e$tUmT3@Bzz"d+JJr4(899 9s<'E%%A|j|}|tur|S| Sr7)r r)rreqs r<r z Float.__ne__Zs$ [[   I6Mract|}tj|s t|St j |Sr7)rrZisinfhashrr)r float_vals r<rzFloat.__hash__as0$K zz)$ ? "~~d##rac   t|}|jrx t j |j t j|j}t j|j}tt|||S|jr/tt||j |j S|jr|tjtjfvr|j!t#|j$}|j$dkDrK|j&r>tt||j |j)|j$Syyyy#t$r tcYSwxYwNr)r rrr(rrrsfrom_intrxrvris_Float is_comparabler rrevalfr.rArEr)rropsmpfompfs r<_Frelz Float._FrelgsB "UOE    << DMM%'',BCD==)DDD$01 1 ^^D4::u{{356 6  U A..30&0KK DJJ 78E{{Q??#D4::u'8'8'DE%GHH#&0 % "! ! "s E;;F  F ct|tr|j|S|j|tj }|t j||S|Sr7)rHrcrrrmpf_gtrrrrrls r<rz Float.__gt__J e\ *<<% % ZZt{{ + :;;tU+ + ract|tr|j|S|j|tj }|t j||S|Sr7)rHrcrrrmpf_gerrrs r<rz Float.__ge__rract|tr|j|S|j|tj }|t j||S|Sr7)rHrcrrrmpf_ltrrrs r<rz Float.__lt__rract|tr|j|S|j|tj }|t j||S|Sr7)rHrcrrrmpf_lerrrs r<rz Float.__le__rrac6t||z t|kSr7)rTrM)rrepsilons r< epsilon_eqzFloat.epsilon_eqs4%< 5>11racRttjt||Sr7)formatrrrI)r format_specs r< __format__zFloat.__format__sgooc$i0+>>raNNT)z1e-15)=rrArBrCrF__annotations__ is_rational is_irrationalr8is_realis_extended_realrrI maketransdictfromkeys_remove_non_digitsrrHrrrrtrrrrpropertyrdrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrrr|rar<rMrMFsdJ#I $$KMIGHt}}V'<=O6b  (65&& 1     ##@ (+)+ (+)+ (+)+ (/)/ ( +) +(,),9@@, ) $ H:2?rarMcfeZdZUdZdZdZdZdZdZde d<de d<dZ e d2dZ d3d Z d Zd Zd Zd ZdZededZeZededZededZededZeZededZededZededZededZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&d Z'd!Z(d"Z)d#Z*d$Z+d%Z,d&Z-d'Z.fd(Z/ d4d)Z0e1d*Z2e1d+Z3eded,Z4eded-Z5d.Z6d5d/Z7d6d0Z8d6d1Z9xZ:S)7raRepresents 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 TFrvrxrSrvrxc~|It|tr|St|trn!t|ttfrtt |St|t s t|}n|jddkDrtd|z|jdd}|jdd}t|dk(r4|\}}tj |}tj |}||z } tj |}t|j"|j$dSt|tstd|zd}d}d}t|ts't|}||j(z}|j*}n t-|}t|ts*t|}||j(z}||j*z}n|t-|z}|}|dk(r9|dk(r$t.dr t'd t0j2St0j4S|dkr| }| }|st7t9||}|dkDr ||z}||z}|dk(r t;|S|dk(r|dk(rt0j<St?j@|}||_||_|S#ttf$rYwxYw#t&$rYwxYw) N/rzinvalid input: %srNr5r2rrnzIndeterminate 0/0)!rHrrrrMryrIrr SyntaxErrorcountrrYrsplitr fractionsFraction numerator denominatorrJrxrvrSrpr rrrrTrHalfrr) rrvrxr:pqfpfqQrs r<rzRational.__new__s 9!X&!Z(a%0#%6q%9::!!S)#AJwws|a''(;a(?@@ #r*A#q)B2w!|!1&//2&//2rEG%..q1 ( Q]]AFF!!X.#$7!$;<<AC !Z( A HAAAA!Z( A HA HA QKA  6AvH%$%89955L$$ $ q5AAs1vq/C 7 #IA #IA 61:  6a1f66Mll3 A)+6&s$ J5J/J,+J,/ J<;J<c tj|j|j}t |j tjt |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 )rrrvrxrlimit_denominatorrS)rmax_denominatorrs r<rzRational.limit_denominatorlsD   tvvtvv .++I,>,>s??S,TUVVrac2|j|jfSr7rrs r<__getnewargs__zRational.__getnewargs__|rac2|j|jfSr7rrs r<rtzRational._hashable_contentrrac |jdkDSrrvrs r<rzRational._eval_is_positivesvvzrac |jdk(Srr rs r<rzRational._eval_is_zerosvv{racDt|j |jSr7)rrvrxrs r<rzRational.__neg__s((rarctjrt|tr;t |j |j |j zz|j dSt|trTt |j |j z|j |j zz|j |j zSt|tr||zStj||Stj||Sr) r1rrHrrrvrxrMrrrs r<rzRational.__add__s  % %%) 7CCE8,uww ?PPE5)t|#~~dE22~~dE**ractjrt|tr;t |j |j |j zz |j dSt|trTt |j |j z|j |j zz |j |j zSt|tr| |zStj||Stj||Sr) r1rrHrrrvrxrMrrrs r<rzRational.__sub__s  % %%) 7CCE8,uww ?PPE5)v}$~~dE22~~dE**ractjrt|tr;t |j |j z|j z |j dSt|trTt |j |j z|j |j zz |j |j zSt|tr| |zStj||Stj||Sr) r1rrHrrrxrvrMr__rsub__rs r<rzRational.__rsub__s  % %%)uww 7CCE8,uww ?PPE5)uu}$tU33tU++rac rtjrt|trLt |j |j z|j t|j |j St|trzt |j |j z|j |j zt|j |j t|j |j zSt|tr||zStj||Stj||Sr7) r1rrHrrrvrxrrMrrrs r<rzRational.__mul__s  % %%)uwwUWWdff8MNNE8,uwwuwwTVVUWW@UVZ[_[a[achcjcjVk@kllE5)Tz!~~dE22~~dE**rac tjrMt|tr|jr-|jt j k(rt jSt|j|j|jzt|j|jSt|trzt|j|jz|j|jzt|j|jt|j|jzSt|tr|d|z zStj||Stj||Sr)r1rrHrrvr rrrrxrrMrrrs r<rzRational.__truediv__s  % %%)66egg/,,,#DFFDFF577NDRR%'T\\(5/:',{{44>>$. .~~dE**raczt|trtj||Stj ||Sr7)rHrrrrrs r<rzRational.__rmod__s0 eX &##E40 0tU++rac"t|tr`t|tr|j|j|zS|j r| }|t jur t|j|jS|jr8t j|zt|j|j |zzSt|j|j|zS|t jur|j|jkDrt jS|j|j kr2t jt jt jzzSt jSt|t r;t|j|jz|j|jzdSt|tr|j|jz}|r|dz }||jz|jz }t||j}|jdk7rLt!|j|zt!|j|zztd|j|zdzSt!|j|ztd|j|zdzS|j|jz }t||j}|jdk7rIt!|j|zt!|j|zztd|jdzSt!|j|ztd|jdzS|j r|j"r| |zSyr)rHrrMrrArr rrrxrvr)r*rrrris_even)rrjneintpart remfracpart ratfracparts r<rzRational._eval_powers dF #$&'' 3T99((U!%%K#DFFDFF33##==$.x/H"/LLL#DFFDFF3R77qzz!66DFF?::%66TVVG#:: 1??(BBBvv $(BB$)&&DFF*qLG")$&&.466"9K"*;"?Kvv{&tvv4WTVV_k5QQRZ[\^b^d^dfm^mopRqqq"466?K7DFFGOUV8WWW"&&&466/K"*;"?Kvv{&tvv4WTVV_k5QQRZ[\^b^d^dfgRhhh"466?K7DFFA8NNN  $ $ED= racbtj|j|j|tSr7)r from_rationalrvrxrers r<rzRational._as_mpf_vals!!!$&&$&&$< ZZx ( :uBB&I{{Brac||j|d}|||f}nt|ts|Stj|S)Nr)r3rHrrrrs r<rzRational.__ge__lr5rac||j|d}|||f}nt|ts|Stj|S)Nr)r3rHrrrrs r<rzRational.__lt__tr5rac||j|d}|||f}nt|ts|Stj|S)Nr)r3rHrrrrs r<rzRational.__le__|r5rac t|Sr7rrs r<rzRational.__hash__rracFddlm}|||||||jS)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_r;copy)rr<r=r>r?r@visualr;s r<factorszRational.factorss) 4Ui%w%''+tv .rac|jSr7r rs r<rzRational.numerator vv rac|jSr7)rxrs r<rzRational.denominatorrFract|tr]|tjk(r|Stt |j |j t |j|jStj||Sr7) rHrr rrrvrrxrr:rs r<r:z Rational.gcds` eX & TVVUWW%TVVUWW%' 'zz$&&ract|trbt|jt|j|jz|jzt|j|jSt j ||Sr7)rHrrvrrxrr=rs r<r=z Rational.lcmsb eX &$tvvuww//%''9TVVUWW%' 'zz$&&racVt|jt|jfSr7r'rs r<as_numer_denomzRational.as_numer_denomstvv//rac|r1|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*)rradicalclears r<as_content_primitivezRational.as_content_primitives= QUU{"5!--' 'uud{rac&|tjfSr1r2r3s r<r4zRational.as_coeff_MulsQUU{rac&|tjfSr6r7r3s r<r8zRational.as_coeff_AddsQVV|rar)i@BNTFFFF)FTr@);rrArBrCr is_integerrr8rFrr(rrrrrtrrrrrr__radd__rrr__rmul__rrrrrrr#rrrrrrr r r3rrrrrrDrrrr:r=rKrOr4r8rIrJs@r<rrs![xGJKII F FK N N`W   )( +) +H( +) +( ,) ,( +) +H( /) /( 0) 0( +) +(,), +Z=N- )+*!+*    ";@5: .(')'(')'0(rarcleZdZdZdZdZdZdZdZdZ dZ e dZ dZ d Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$d Z%d!Z&d"Z'fd#Z(d$Z)d%Z*d&Z+e,d'e-d(Z.d)Z/d*Z0d+Z1d,Z2d-Z3d.Z4d/Z5d0Z6d1Z7d2Z8d3Z9d4Z:xZ;S)5rajRepresents 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. rTr|cLtj|j|tSr7)rrrvrers r<rzInteger._as_mpf_vals}}TVVT3//racJtj|j|Sr7)rur!rr"s r<r#zInteger._mpmath_st//566racNt|tr|jdd} t|}|dk(rt j S|dk(rt jS|dk(rt jStj|}||_ |S#t$rt d|zwxYw)NrNr5z6Argument of Integer should be of numeric type, got %s.rrtr) rHrIrYrSrr rr*rrrrv)rr;ivalrs r<rzInteger.__new__s a  #r"A Nq6D 1955L 2:== 1966Mll3  NH1LN N Ns B B$c|jfSr7r rs r<rzInteger.__getnewargs__syrac|jSr7r rs r<rzInteger.__int__ vv rac,t|jSr7rrvrs r<rz Integer.floortvvrac,t|jSr7r_rs r<rzInteger.ceilingr`rac"|jSr7rrs r<rzInteger.__floor__rrac"|jSr7rrs r<rzInteger.__ceil__!rrac.t|j Sr7r_rs r<rzInteger.__neg__$wracP|jdk\r|St|j Sr)rvrrs r<rzInteger.__abs__'s# 66Q;KDFF7# #ract|tr6tjr&t t |j |j Stj||Sr7) rHrr1rrrrvrrrs r<rzInteger.__divmod__-sB eW %*;*D*D6$&&%''24 4$$T51 1racPt|tr,tjrt t ||j S t|}tj||S#t$r=d}t|j}t|j}t|||fzwxYw)Nz7unsupported operand type(s) for divmod(): '%s' and '%s') rHrSr1rrrrvrrrrr)rrronamesnames r<rzInteger.__rdivmod__3s eS !&7&@&@6%02 2 6u  $$UD1 1  6OU ,,T ++uen 455  6s AAB%ctjrt|trt |j |zSt|tr"t |j |j zSt|t r;t |j |jz|j z|jdSt j||St||Sr) r1rrHrSrrvrrxrAddrs r<rzInteger.__add__As  % %%%tvv~..E7+tvv/00E8,uww 8%''1EE##D%0 0tU# #rac`tjrt|trt ||j zSt|t r;t |j |j |jzz|jdSt j||St j||Sr) r1rrHrSrrvrrxrTrs r<rTzInteger.__radd__M  % %%%utvv~..E8,$&&. 8%''1EE$$T51 1  u--ractjrt|trt |j |z St|tr"t |j |j z St|t r;t |j |jz|j z |jdSt j||St j||Sr) r1rrHrSrrvrrxrrs r<rzInteger.__sub__Vs  % %%%tvv~..E7+tvv/00E8,uww 8%''1EE##D%0 0e,,rac`tjrt|trt ||j z St|t r;t |j |j |jzz |jdSt j||St j||Sr) r1rrHrSrrvrrxrrs r<rzInteger.__rsub__arnractjrt|trt |j |zSt|tr"t |j |j zSt|t rLt |j |j z|jt|j |jSt j||St j||Sr7) r1rrHrSrrvrrxrrrs r<rzInteger.__mul__js  % %%%tvve|,,E7+tvvegg~..E8,uwwdffegg9NOO##D%0 0e,,ractjrt|trt ||j zSt|t rLt |j |j z|jt|j |jSt j||St j||Sr7) r1rrHrSrrvrrxrrUrs r<rUzInteger.__rmul__us  % %%%uTVV|,,E8,dffegg9NOO$$T51 1  u--rac.tjrpt|trt |j |zSt|tr"t |j |j zSt j||St j||Sr7)r1rrHrSrrvrrrs r<rzInteger.__mod__~sp  % %%%tvv~..E7+tvv/00##D%0 0e,,rac.tjrpt|trt ||j zSt|tr"t |j |j zSt j||St j||Sr7)r1rrHrSrrvrrrs r<rzInteger.__rmod__sp  % %%%utvv~..E7+uww/00$$T51 1  u--ract|tr|j|k(St|tr|j|jk(Stj ||Sr7)rHrSrvrrr rs r<r zInteger.__eq__sH eS !FFeO $ w 'FFegg% &tU++rac||k( Sr7r|rs r<r zInteger.__ne__r/rac t|}|jr"t|j|jkDSt j ||S#t$r tcYSwxYwr7)r rrrrvrrrs r<rzInteger.__gt__[ "UOE   DFFUWW,- -tU++  "! ! " AA#"A#c t|}|jr"t|j|jkSt j ||S#t$r tcYSwxYwr7)r rrrrvrrrs r<rzInteger.__lt__rxryc t|}|jr"t|j|jk\St j ||S#t$r tcYSwxYwr7)r rrrrvrrrs r<rzInteger.__ge__[ "UOE   DFFegg-. .tU++  "! ! "ryc t|}|jr"t|j|jkSt j ||S#t$r tcYSwxYwr7)r rrrrvrrrs r<rzInteger.__le__r|ryc,t|jSr7)rrvrs r<rzInteger.__hash__sDFF|rac|jSr7r rs r< __index__zInteger.__index__r]rac2t|jdzSNr2)rrvrs r< _eval_is_oddzInteger._eval_is_oddsDFFQJrac ddlm}|tjur_|jtj kDrtjStjtj tjzzS|tjurtd|dtjzSt|ts|jr|jr| |zSt|trt|=|St|tsy|tj ur*|jrtj t#| |zS|jrN| }|jr%tj$|ztd| d|zzStd|jd|zSt't)|j|j*\}}|rEt-|t)|jz}|jr|tj$|zz}|St/t)|j}||}|dur |d|di} nt-|j1d} d} d} d} d} i}| j3D]\}}||jz}t5||j*\}}|dkDr| ||zz} |dkDsAt7||j*}|dk7r+| t#|t||z|j*|zdz} |||<|j3D] \}}| dk(r|} t7| |} | dk(s n|j3D]\}}| ||| zzz} | |k(r| dk(r | dk(rd}|S| | zt#| t| |j*z}|jr|t#tj$|z}|S)av Tries to do some simplifications on self**expt Returns None if no further simplifications can be done. Explanation =========== When exponent is a fraction (so we have for example a square root), we try to find a simpler representation by factoring the argument up to factors of 2**15, e.g. - sqrt(4) becomes 2 - sqrt(-4) becomes 2*I - (2**(3+7)*3**(6+7))**Rational(1,7) becomes 6*18**(3/7) Further simplification would require a special call to factorint on the argument which is not done here for sake of speed. r) perfect_powerrNFi)r<)rArr rrvrrrrrHrr)rrMrrrrr*rrTrxrrSrDitemsrr)rrjrrxxexactresultb_posrvrout_intout_radsqr_intsqr_gcdsqr_dictprimeexponentdiv_ediv_mrexkvrs r<rzInteger._eval_powersk* 8 1:: vv~zz!:: :: : 1%% %AtQ'3 3$'DLL}$ dE "7&t, ,$)  166>d..??3ud#33 3   B}}d*8Aua+@"+DDD4661-r11#CK8 6 QDFF ^,F!----M CK  %  E>aD!A$)))6D#zz| ,OE8  H!(DFF3LE5qy5%<'qy'6s5(5!8TVVQY*JKKG&+HUO ,^^% EAr!|w+a<  NN$ 'DAq q1g: &G ' e 1 AF  W_S(7DFF2K%LLF#ammT22 racddlm}||S)Nr)isprime)sympy.ntheory.primetestr)rrs r<_eval_is_primezInteger._eval_is_prime5s3t}rac8|dkDrt|jSy)NrF)ris_primers r<_eval_is_compositezInteger._eval_is_composite:s !8T]]+ +rac&|tjfSr7r2rs r<rKzInteger.as_numer_denom@sQUU{rarct|tstSt|trt|j|zSt ||dSr)rHrrrrvrrs r< __floordiv__zInteger.__floordiv__CsA%&! ! eW %466U?+ +dE"1%%racXtt|j|jzSr7r_rs r< __rfloordiv__zInteger.__rfloordiv__Ks wu~''466122ract|tttjfr!t|j t|zSt Sr7rHrSrnumbersIntegralrvrrs r< __lshift__zInteger.__lshift__U7 ec7G,<,<= >466SZ/0 0! !ract|ttjfr!t t||j zSt Sr7rHrSrrrrvrrs r< __rlshift__zInteger.__rlshift__[5 ec7#3#34 53u:/0 0! !ract|tttjfr!t|j t|z St Sr7rrs r< __rshift__zInteger.__rshift__arract|ttjfr!t t||j z St Sr7rrs r< __rrshift__zInteger.__rrshift__grract|tttjfr!t|j t|zSt Sr7rrs r<__and__zInteger.__and__m7 ec7G,<,<= >466CJ./ /! !ract|ttjfr!t t||j zSt Sr7rrs r<__rand__zInteger.__rand__s5 ec7#3#34 53u:./ /! !ract|tttjfr!t|j t|z St Sr7rrs r<__xor__zInteger.__xor__yrract|ttjfr!t t||j z St Sr7rrs r<__rxor__zInteger.__rxor__rract|tttjfr!t|j t|zSt Sr7rrs r<__or__zInteger.__or__rract|ttjfr!t t||j zSt Sr7rrs r<__ror__zInteger.__ror__rrac.t|jSr7r_rs r< __invert__zInteger.__invert__rera)>> 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_polynomialNPolygenTpolysr) dup_compose)Symbol)sympy.polys.polyclassesrrsympy.polys.numberfieldsrrrHrris_Polyrris_AlgebraicNumberrrrrget get_domainfrom_sympy_list from_listto_listsympy.polys.densetoolsrdegreeremsymbolrrrr)rexprcoeffsrrrrrrep0alias0rrrdomrscoeffsrcsargsrrs r<rzAlgebraicNumber.__new__sR 5?t} dUEN + MGT??6w-  $ $+/<<+/88TZZ+A 'GT4/dhhuoT348G  "  fc*))'&/1cB.mmFNN$4a=!12--A3/CAqkG   :CKKM4<<>3?A--1c*CQiG ::<7>>+ +'''++&Cw   &eV,u UH$Ell3''   rac t|Sr7rrs r<rzAlgebraicNumber.__hash__ rrac@|jj|Sr7)as_expr_evalfrs r<rzAlgebraicNumber._eval_evalf s||~$$T**rac|jduS)z'Returns ``True`` if ``alias`` was set. N)rrs r< is_aliasedzAlgebraicNumber.is_aliased szz%%racddlm}m}||j|j|S|j &|j|j|j Sddlm}|j|j|dS)z&Create a Poly instance from ``self``. r)rPurePolyrDummyr)rrrrrrrr)rrrrrs r<as_polyzAlgebraicNumber.as_poly s^8 =88DHHa( (zz%xx$**55)||DHHeCj99racx|j|xs |jjjS)z)Create a Basic expression from ``self``. )rrrexpand)rrs r<rzAlgebraicNumber.as_expr s+||AN+335<<>>rac|jjDcgc]'}|jjj|)c}Scc}w)z7Returns all SymPy coefficients of an algebraic number. )r all_coeffsrto_sympyrrs r<rzAlgebraicNumber.coeffs s637883F3F3HJa&&q)JJJs,A c6|jjS)z8Returns all native coefficients of an algebraic number. )rrrs r< native_coeffszAlgebraicNumber.native_coeffs sxx""$$racxddlm}|j}|jdk(r|S|j|j dz z}|j ||j |jz }||z}|j|jz}t||f|jS)z*Convert ``self`` to an algebraic integer. rrr) rrrLCrcomposerrrr)rrrcoeffpolyrrs r<to_algebraic_integerz$AlgebraicNumber.to_algebraic_integer s. LL 446Q;Ka(yyaeeADDFl+,u*ttvdii >>rac Lddlm}ddlm}|d|d}}|jj Dcgc]}|j |k7s|c}D]M}||j |z js#|||||j zksBt|cS|Scc}w)Nr)CRootOfrmeasureratio) sympy.polys.rootoftoolsr sympy.polysr all_rootsfuncr is_Symbolr)rr,rrrrrs r<_eval_simplifyzAlgebraicNumber._eval_simplify s3' *F7O!\\335K79J!K .Atyy1}%//1:gdii&8 88*1--  .  Ls B!B!c^t|j|jf||jS)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)rrs r< field_elementzAlgebraicNumber.field_element s,P \\499 %fDJJH HracT|j}|ddgk(xs||jgk(S)z Say whether this algebraic number $\alpha \in \mathbb{Q}(\theta)$ is equal to the primitive element $\theta$ for its field. rr)rrrs r<is_primitive_elementz$AlgebraicNumber.is_primitive_element s- KKMQF{.aDII;..racD|jr|S|jddgS)z Get the primitive element $\theta$ for the number field $\mathbb{Q}(\theta)$ to which this algebraic number $\alpha$ belongs. Returns ======= AlgebraicNumber rr)rrrs r<primitive_elementz!AlgebraicNumber.primitive_element s'  $ $K!!1a&))rac||jr|S|j}|j|}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)rrrrs r<to_primitive_elementz$AlgebraicNumber.to_primitive_element# s@B  $ $K  # # % LL(L +1v&&rac|j]|jr|j|_|jSddlm}|j }||j |d|_|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$. rrTr)rrr sympy.polys.numberfields.minpolyrr)rrthetas r<rz"AlgebraicNumber.minpoly_of_elementj sk    $(($(LL!    E..0$+DLL,?t$L!   rac4|jr&t|jts |jS|xs|j }|j |}t |dk(r|dS|j}|D]}|j||s|cSy)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) rrHrrrr rr same_root)rrrrrootsrrYs r<rzAlgebraicNumber.to_root s(  $ $Z ?-S99   0t..0 X . u:?8O \\^ A{{1b! rarr7r)TN)rrArBrCrFr is_algebraicr8rrGsetrrrrrrrrrrrrr rrrrrrrIrJs@r<rrs"DILI D #uL*$fP"+&& :?K%?" )HV// *E'N!,rarceZdZdZdZdZy)RationalConstantz Abstract base class for rationals with specific behaviors Derived classes must define class attributes p and q and should probably all be singletons. r|c,tj|Sr7rrrs r<rzRationalConstant.__new__ !!#&&raN)rrArBrCrFrr|rar<r"r" s I'rar"ceZdZdZdZy)IntegerConstantr|c,tj|Sr7r$rs r<rzIntegerConstant.__new__ r%raN)rrArBrFrr|rar<r'r' s I'rar'cheZdZdZdZdZdZdZdZdZ dZ dZ dZ e dZe d Zd Zd Zd Zy )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 rrFTr|cyr'r|rs r<rzZero.__getnewargs__ rac"tjSr7r7r|rar<rz Zero.__abs__ vv rac"tjSr7r7r|rar<rz Zero.__neg__ r-rac^|jr|S|jrtjS|jdurtj S|j rtjS|j\}}|jrtj|zS|tjur||zSyr,) rrr rrrrrr4r))rrjrtermss r<rzZero._eval_power s  $ $K  $ $$$ $  E )55L <<55L ((* u   $$e+ +  ;  rac|Sr7r|rrs r<rzZero._eval_order  racyr,r|rs r<rz Zero.__bool__ sraN)rrArBrCrvrxrr)rr8rrFr staticmethodrrrrrr|rar<rr sm& A AKKGIMI&rar) metaclasscleZdZdZdZdZdZdZdZdZ e dZ e dZ dZ d Ze d d Zy ) 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 Trr|cyr'r|rs r<rzOne.__getnewargs__ r+rac"tjSr7r2r|rar<rz One.__abs__ uu rac"tjSr7)r r*r|rar<rz One.__neg__ s }}rac|Sr7r|rrjs r<rzOne._eval_power rracyr7r|r2s r<rzOne._eval_order sraNc*|rtjSiSr7r2)r<r=r>r?r@rCs r<rDz One.factors" s 55LIrarR)rrArBrCr8rrvrxrFrr5rrrrrDr|rar<rr ss IK A AICH&+rarcLeZdZdZdZdZdZdZdZe dZ e dZ d Z y ) r*a]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 Trtrr|cyr'r|rs r<rzNegativeOne.__getnewargs__I r+rac"tjSr7r2r|rar<rzNegativeOne.__abs__L r:rac"tjSr7r2r|rar<rzNegativeOne.__neg__P r:rac|jrtjS|jrtjSt |t rt |trtd|zS|tjurtjS|tjtjfvrtjS|tjurtjSt |try|jdk(r&tjt|j zSt#|j |j\}}|r||z|t||jzzSy)Ngr2)is_oddr r*rrrHrrMrrrrrrrxrrvr)rrjr;rs r<rzNegativeOne._eval_powerT s ;;== <<55L dF #$&T{D((quu}uu  A$6$677uu qvv~&$)66Q;??GDFFO;;dffdff-174!TVV)<#<<<raN) rrArBrCr8rvrxrFrr5rrrr|rar<r*r*+ sO,I A AIrar*c6eZdZdZdZdZdZdZdZe dZ y) raThe 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 Trr2r|cyr'r|rs r<rzHalf.__getnewargs__ r+rac"tjSr7)r rr|rar<rz Half.__abs__ r-raN) rrArBrCr8rvrxrFrr5rr|rar<rrk s6 I A AIrarceZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZddZdd Zed ed ZeZed ed Zed ed Zed edZeZed edZdZdZdZdZfdZdZ dZ!e"jFZ#e"jHZ$e"jJZ%e"jLZ&ed edZ'e'Z(dZ)dZ*xZ+S)raPositive 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 TFr|c,tj|Sr7r$rs r<rzInfinity.__new__ r%racy)Nz\inftyr|rprinters r<_latexzInfinity._latex rac||k(r|Syr7r|rs r<rzInfinity._eval_subs  3;J ractdSNrrMrs r<rzInfinity._eval_evalf s U|rac $|j|Sr7rrrgoptionss r<rzInfinity.evalf %%rarct|trDtjr4|tj tj fvrtj S|Stj||Sr7)rHrr1rr rrrrs r<rzInfinity.__add__ K eV $):)C)C++QUU33uu K~~dE**ract|trDtjr4|tj tj fvrtj S|Stj||Sr7)rHrr1rr rrrrs r<rzInfinity.__sub__ I eV $):)C)CQUU++uu K~~dE**rac&| j|Sr7rrs r<rzInfinity.__rsub__ u%%ract|tr\tjrL|js|t j urt j S|jr|St jStj||Sr7) rHrr1rrr rrrrrs r<rzInfinity.__mul__ sZ eV $):)C)C}}uu )) %% %~~dE**rac6t|trttjrd|tj us$|tj us|tjurtjS|jr|Stj Stj||Sr7 rHrr1rr rrris_extended_nonnegativerrs r<rzInfinity.__truediv__ sp eV $):)C)C "+++QUUNuu ,, %% %!!$..rac"tjSr7r rrs r<rzInfinity.__abs__ zzrac"tjSr7)r rrs r<rzInfinity.__neg__ s!!!rac|jrtjS|jrtjS|tj urtj S|tj urtj S|jdur|jruddl m }||}|jrtj S|jrtjS|jrtj S||jzSyy)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)rN)rr rrrrrrr8rrrr)rr)rrjr expt_reals r<rzInfinity._eval_power s$  $ $::   $ $66M 155=55L 1$$ $55L  E )dnn ?4I$$((($$vv   uu % %/= )rac"tjSr7)rr)rs r<rzInfinity._as_mpf_val' s yyrac t|Sr7rrs r<rzInfinity.__hash__* rracF|tjuxs|tdk(SrSr rrrs r<r zInfinity.__eq__- s ";euU|&;;racF|tjuxr|tdk7SrSrnrs r<r zInfinity.__ne__0 sAJJ&@5E%L+@@racNt|tstStjSr7rHrrr rrs r<rzInfinity.__mod__8 %&! !uu rac|Sr7r|rs r<rzInfinity.floor@ rrac|Sr7r|rs r<rzInfinity.ceilingC rrar7),rrArBrCrDr8 is_complexrrrrrrFrrNrrrrrrrTrrrrUrrrrrrr r rrrrrrrrrrIrJs@r<rr sY&PNIJKMHI'&(+)+ H(+)+(&)&(+)+H( /) /"$&L"<A[[F [[F [[F [[F() HrarceZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZddZdd Zed ed ZeZed ed Zed ed Zed edZeZed edZdZdZdZdZfdZdZ dZ!e"jFZ#e"jHZ$e"jJZ%e"jLZ&ed edZ'e'Z(dZ)dZ*dZ+xZ,S)rzNegative infinite quantity. NegativeInfinity is a singleton, and can be accessed by ``S.NegativeInfinity``. See Also ======== Infinity TFr|c,tj|Sr7r$rs r<rzNegativeInfinity.__new__` r%racy)Nz-\inftyr|rLs r<rNzNegativeInfinity._latexc srac||k(r|Syr7r|rs r<rzNegativeInfinity._eval_subsf rQractdSNrrTrs r<rzNegativeInfinity._eval_evalfj s V}rac $|j|Sr7rVrWs r<rzNegativeInfinity.evalfm rYrarct|trDtjr4|tj tj fvrtj S|Stj||Sr7)rHrr1rr rrrrs r<rzNegativeInfinity.__add__p r]ract|trDtjr4|tj tj fvrtj S|Stj||Sr7)rHrr1rr rrrrs r<rzNegativeInfinity.__sub__y r[rac&| j|Sr7r_rs r<rzNegativeInfinity.__rsub__ r`ract|tr\tjrL|js|t j urt j S|jr|St jStj||Sr7) rHrr1rrr rrrrrs r<rzNegativeInfinity.__mul__ sX eV $):)C)C}}uu )) :: ~~dE**rac6t|trttjrd|tj us$|tj us|tjurtjS|jr|Stj Stj||Sr7rcrs r<rzNegativeInfinity.__truediv__ sn eV $):)C)C "+++QUUNuu ,, :: !!$..rac"tjSr7rfrs r<rzNegativeInfinity.__abs__ rgrac"tjSr7rfrs r<rzNegativeInfinity.__neg__ rgrac*|jr|tjus$|tjus|tjurtjSt |t r8|jr,|jrtjStjStj|z}tj|z}|dk(r|jr|S|tjur(|jr|jstjS||zSy)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) r8r rrrrHrrrEr*r~rr)rrjinf_parts_parts r<rzNegativeInfinity._eval_power s, >>quu} "A...uu $(T-F-F;;---::%zz4'H]]D(F1}!1!1A---$$V^^((((? "' rac"tjSr7)rr*rs r<rzNegativeInfinity._as_mpf_val s zzrac t|Sr7rrs r<rzNegativeInfinity.__hash__ rracF|tjuxs|tdk(Sr{r rrrs r<r zNegativeInfinity.__eq__ s!***DeuV}.DDracF|tjuxr|tdk7Sr{rrs r<r zNegativeInfinity.__ne__ s!A...I5E&M3IIracNt|tstStjSr7rqrs r<rzNegativeInfinity.__mod__ rrrac|Sr7r|rs r<rzNegativeInfinity.floor rrac|Sr7r|rs r<rzNegativeInfinity.ceiling rracFtjdtjdiSr)r r*rrs r<as_powers_dictzNegativeInfinity.as_powers_dict s q!**a00rar7)-rrArBrCrrurDrrrr8rrFrrNrrrrrrrTrrrrUrrrrrrr r rrrrrrrrrrrIrJs@r<rrI s^ JNKMIHI'&(+)+ H(+)+(&)&(+)+H( /) /)#V"EJ[[F [[F [[F [[F() H1rarcfeZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZdZdZdZdZed ed Zed ed Zed ed Zed ed ZdZdZdZfdZdZ dZ!e"jFZ#e"jHZ$e"jJZ%e"jLZ&xZ'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 TNFr|c,tj|Sr7r$rs r<rz NaN.__new__1 r%racy)Nz \text{NaN}r|rLs r<rNz NaN._latex4 srac|Sr7r|rs r<rz NaN.__neg__7 rrarc|Sr7r|rs r<rz NaN.__add__: r3rac|Sr7r|rs r<rz NaN.__sub__> r3rac|Sr7r|rs r<rz NaN.__mul__B r3rac|Sr7r|rs r<rzNaN.__truediv__F r3rac|Sr7r|rs r<rz NaN.floorJ rrac|Sr7r|rs r<rz NaN.ceilingM rractSr7)rkrs r<rzNaN._as_mpf_valP srac t|Sr7rrs r<rz NaN.__hash__S rrac&|tjuSr7r rrs r<r z NaN.__eq__V s~rac&|tjuSr7rrs r<r z NaN.__ne__Z sAEE!!ra)(rrArBrCrDrrrris_transcendentalrSrr~rrrr)r8rFrrNrrrrrrrrrrrr r rrrrrrIrJs@r<rr s.^NGKLJMIGHKKII'()()()()""[[F [[F [[F [[Frarcyr,r|)rXrYs r< _eval_is_eqre  racneZdZdZdZdZdZdZdZdZ e Z dZ dZ dZedZdZd Zed Zd Zy ) raComplex 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 TFr|c,tj|Sr7r$rs r<rzComplexInfinity.__new__ r%racy)Nz\tilde{\infty}r|rLs r<rNzComplexInfinity._latex s rac"tjSr7rfr|rar<rzComplexInfinity.__abs__ s zzrac|Sr7r|rs r<rzComplexInfinity.floor rrac|Sr7r|rs r<rzComplexInfinity.ceiling rrac"tjSr7)r rr|rar<rzComplexInfinity.__neg__ s   rac|tjurtjSt|trH|j rtjS|j rtjStjSyr7)r rrrHrrrrr=s r<rzComplexInfinity._eval_power sV 1$$ $55L dF #||uu ##,,,66M $raN)rrArBrCrDrr8rrurrrGrFrrNr5rrrrrr|rar<rrj ss>NKIHJ DI'!!! "rarcfeZdZdZdZdZdZdZeZ dZ dZ dZ dZ dZdZd Zd Zfd ZxZS) rcTr|c,tj|Sr7r$rs r<rzNumberSymbol.__new__ r%racy)z Return an interval with number_cls endpoints that contains the value of NumberSymbol. If not implemented, then return None. Nr|r number_clss r< approximationzNumberSymbol.approximation sracLtj|j||Sr7rrs r<rzNumberSymbol._eval_evalf rrac t|}||ury|jr |jryy#t$r tcYSwxYwr)r rrrErrs r<r zNumberSymbol.__eq__ sH "UOE 5= ??t11 "! ! "s ,>>c||k( Sr7r|rs r<r zNumberSymbol.__ne__ r/racV||urtjStj||Sr7)r truerrrs r<rzNumberSymbol.__le__ # 5=66M{{4''racV||urtjStj||Sr7)r rrrrs r<rzNumberSymbol.__ge__ rractr7)rrs r<rzNumberSymbol.__int__ s!!rac t|Sr7rrs r<rzNumberSymbol.__hash__ rra)rrArBrDr~r8rFr-rrGrrrr r rrrrrIrJs@r<rcrc sSNIIIO D' 8 !( ( """rarccpeZdZdZdZdZdZdZdZdZ dZ dZ dZ e dZdZdZd Zd Zd Zd Zd Zy)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 TFr|cy)Nrr|rLs r<rNz Exp1._latexr$rac"tjSr7)r rr|rar<rz Exp1.__abs__r-racyrr|rs r<rz Exp1.__int__ ract|Sr7)r&rs r<rzExp1._as_mpf_val#s T{racrt|trtdtdfSt|tryy)Nr2rQ issubclassrrrs r<approximation_intervalzExp1.approximation_interval&s1 j' *AJ + +  H - .rac`tjr|j|Sddlm}||S)Nr)rp)r1 exp_is_pow_eval_power_exp_is_pow&sympy.functions.elementary.exponentialrp)rrjrps r<rzExp1._eval_power,s)  ' '..t4 4 Bt9 rac|jr(|turtS|t k(rtjSddlm}t ||r|jdS|jsttz}||| fvrtS|jttz}|rd|zjr|jrtjS|j rtj"S|tj$zjrt S|tj$zj r[tS|j&rI|dz}|dkDr|dz}||k7r5tj(|tj*ztj,zzS|j/\}}|tt fvry|gd}}t1j2|D]A} t | |r|| jd}!y| j4r|j7| Ay|r |t1|zSdS|jrg} g} d} |jD]} | tjur| j7| '|| z}t |t8rM|j:|ur?|j<| k7r| j7|j<d} w| j7| | j7|| s| rt1| t9|t?| dzSy|j@r|j=Sy)Nr)logr2rFTr)!rEoor rrrrHris_AddIrrpirSrrrEr*rr(rPirr4Mul make_argsrappendrbaserprl is_Matrix)rrqrIoorncoeffr0rlog_termtermoutadd argchangedrXnewas r<rzExp1._eval_power_exp_is_pow3s ==by vv > c3 88A; B$CsSDk! IIbdOEeG''}} uu  }},!&&.11 !r !&&.00 &&"QYFz!  vvqtt AOO(CDD++-LE5bS ! %wHF e, dC('#'99Q<''MM$' .68S&\) ?4 ? ZZCCJXX %:JJqMQwdC(TYY$->xx1} 488,%)  1 JJt$ %jCyT39u!EEE! ]]779 rac vddlm}|ttjdz zt|tzz S)Nr)sinr2)(sympy.functions.elementary.trigonometricrrr r)rr,rs r<_eval_rewrite_as_sinzExp1._eval_rewrite_as_sins(@1qttAv:3q6))rac vddlm}|tt|ttjdz zzzS)Nr)cosr2)rrrr r)rr,rs r<_eval_rewrite_as_coszExp1._eval_rewrite_as_coss)@1v#a!$$q&j/)))raN)rrArBrCrrr)rr8rrrFrNr5rrrrrrrrr|rar<rr sp6GKKMILI N`**rarcXeZdZdZdZdZdZdZdZdZ dZ dZ dZ e dZdZdZd Zy ) raThe `\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 TFr|cy)Nz\pir|rLs r<rNz Pi._latexsrac"tjSr7)r rr|rar<rz Pi.__abs__s tt racy)NrQr|rs r<rz Pi.__int__rract|Sr7)r%rs r<rzPi._as_mpf_vals d|ract|trtdtdfSt|trtdddtdddfSy)NrQrRGrrrs r<rzPi.approximation_intervalsK j' *AJ + +  H -S"a((2q!*<= =.raN)rrArBrCrrr)rr8rrrFrNr5rrrrr|rar<rrs[!FGKKMILI>rarcReZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZd ZeZy ) GoldenRatioaThe golden ratio, `\phi`. Explanation =========== `\phi = \frac{1 + \sqrt{5}}{2}` is an algebraic number. Two quantities are in the golden ratio if their ratio is the same as the ratio of their sum to the larger of the two quantities, i.e. their maximum. GoldenRatio is a singleton, and can be accessed by ``S.GoldenRatio``. Examples ======== >>> 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 TFr|cy)Nz\phir|rLs r<rNzGoldenRatio._latexsracyrr|rs r<rzGoldenRatio.__int__rracftjt|dz| dz }t||SNrF)r from_man_expr'rmr~s r<rzGoldenRatio._as_mpf_vals0   y3dURZ @D!!rac bddlm}tjtj|dzzS)Nr)sqrtrG)(sympy.functions.elementary.miscellaneousrr r)rhintsrs r<_eval_expand_funczGoldenRatio._eval_expand_funcs AvvtAw&&rac|t|trtjt dfSt|tryyrrrr rrrs r<rz"GoldenRatio.approximation_interval1 j' *EE8A;' '  H - .raN)rrArBrCrrr)rr8rrrFrNrrrr_eval_rewrite_as_sqrtr|rar<rrsS8GKKMILI" ' .rarcXeZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZd Zd ZeZy ) 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 TFr|cy)Nz\text{TribonacciConstant}r|rLs r<rNzTribonacciConstant._latex@s+racyrr|rs r<rzTribonacciConstant.__int__Crrac8|j|jSr7)rrsrs r<rzTribonacciConstant._as_mpf_valFs%+++racd|jdj|dz}t||S)NT)functionrRr)rrrMr~s r<rzTribonacciConstant._eval_evalfIs1  # #T # 2 > >tax HR4((rac pddlm}m}d|dd|dzz z|dd|dzzzdz S)Nr)cbrtrrrQ!)rrr)rrrrs r<rz$TribonacciConstant._eval_expand_funcMs<GDaRj))DaRj,AAQFFrac|t|trtjt dfSt|tryyrrrs r<rz)TribonacciConstant.approximation_intervalQrraN)rrArBrCrrr)rr8rrrFrNrrrrrrr|rar<rrsZ"HGKKMILI,,)G .rarc@eZdZdZdZdZdZdZdZdZ dZ dZ dZ d Z y) 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 TFNr|cy)Nz\gammar|rLs r<rNzEulerGamma._latexrOracyrr|rs r<rzEulerGamma.__int__rractjj|dz}tj|| dz }t ||Sr)rlibhyper euler_fixedrrmrrgrrls r<rzEulerGamma._as_mpf_vals? MM % %dRi 0   q4%"* -D!!ract|tr tjtjfSt|t rtj t dddfSy)NrQrGr)rrr rrrrrs r<rz!EulerGamma.approximation_intervalsE j' *FFAEE? "  H -FFHQ1-. ..ra)rrArBrCrrr)rr8rFrNrrrr|rar<r r Zs;>GKKMII" /rar cHeZdZdZdZdZdZdZdZdZ dZ dZ dZ d d Z d Zy) 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 TFNr|cyrr|rs r<rzCatalan.__int__rrac~tj|dz}tj|| dz }t||Sr)r catalan_fixedrrmrs r<rzCatalan._as_mpf_vals;   tby )   q4%"* -D!!ract|tr tjtjfSt|t rt dddtjfSy)N rFr)rrr rrrrs r<rzCatalan.approximation_intervalsE j' *FFAEE? "  H -QA&. ..rac |||Sddlm}ddlm}|ddd}|tj |zd|zdzdzz |dtj fS) Nrrr)SumrT)integer nonnegativer2)rrsympy.concrete.summationsrr r*r)rk_symrrrrrs r<_eval_rewrite_as_SumzCatalan._eval_rewrite_as_SumsX  7#6K!1 #t 61==!#qs1uqj01a2DEEracy)NGr|rLs r<rNzCatalan._latexsrar)rrArBrCrrr)rr8rFrrrr!rNr|rar<rrsA6GKKMII" / FrarcneZdZdZdZdZdZdZdZdZ e Z dZ dZ edZdZdZd Zd Zed Zy ) raTThe 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 TFr|c |jdS)Nimaginary_unit_latex) _settingsrLs r<rNzImaginaryUnit._latexs  !788rac"tjSr7r2r|rar<rzImaginaryUnit.__abs__r:rac|Sr7r|rs r<rzImaginaryUnit._eval_evalfrrac$tj Sr7)r rrs r<rzImaginaryUnit._eval_conjugatesract|trZ|dz}|dk(rtjS|dk(rtjS|dk(rtj S|dk(rtj St|t rNt|d\}}ttj|d}|dzrttj |dS|Sy) a b is I = sqrt(-1) e is symbolic object but not equal to 0, 1 I**r -> (-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 rRrrr2rQFrN) rHrr rrr*rrrr)rrjr;rrls r<rzImaginaryUnit._eval_powers dG $!8Dqyuu &}}$'' dH %$?DAqQ__a%8B1u1=="u==I &racBtjtjfSr7)r r*rrs r< as_base_expzImaginaryUnit.as_base_exp s}}aff$$racVtdjtdjfS)Nrr)rMrsrs r<_mpc_zImaginaryUnit._mpc_#saa//raN)rrArBrCrD is_imaginaryr~r8rrrrGrFrNr5rrrrr-rr/r|rar<rrss,NLIIL DI9 :%00rarct|ttfryt|tur|j St|t ryt|tr|jddk\Sy)zreturn True only for a literal Number whose internal representation as a fraction has a denominator of 1, else False, i.e. integer, with no fractional part. Tr2rF) rHrrSrrrSrrMrsrs r<rr+sZ !j#&' Aw%||~!W!UwwqzQ racBt|}t|}|js|js||k(S|jr%|jr|j|jk(S|jr||}}|jsy|j\}}}}|j|j }}|r| }|dk(r |dk(xr||k(S|dkDr3|dk7ry|j |j |zk7ry||z|k(S||k7ry| }|j dz |k7ryd|z|k(S)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) False 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 Frr)r rrsr(rvrx bit_length) rrrhrirpr\rvrxneg_exps r<rr<s&j  A A ::ajjAv  ww!''!! !1 == D#sA 33qA d axAv"#(" q 6 <<>S^^-3 3czQ 8$ <<>A  (W ""racrttffdfdt|t|||S)aReturn True if expr1 and expr2 are numerically close. The expressions must have the same structure, but any Rational, Integer, or Float numbers they contain are compared approximately using rtol and atol. Any other parts of expressions are compared exactly. Relative tolerance is measured with respect to expr2 so when used in testing expr2 should be the expected correct answer. Examples ======== >>> from sympy import exp >>> from sympy.abc import x, y >>> from sympy.core.numbers import all_close >>> expr1 = 0.1*exp(x - y) >>> expr2 = exp(x - y)/10 >>> expr1 0.1*exp(x - y) >>> expr2 exp(x - y)/10 >>> expr1 == expr2 False >>> all_close(expr1, expr2) True ct|}t|}||k7ry|r)tt||z t|zzkS|jr||k(S|j|jk7s+t |j t |j k7ry|js |jr  ||St|j |j }tfd|DS)NFc3:K|]\}}||ywr7r|)r:a1a2 _all_closeatolrtols r<r=z0all_close.._all_close..s I&"bz"b$5Is) rHrrTis_Atomr rrris_MulrQrK) expr1expr2r=r<num1num2r NUM_TYPESr; _all_close_acs `` r<r;zall_close.._all_closes%+%+ 4< EEM*dT#e*_.DDE E ]]E> ! ZZ5:: %UZZC O)K \\U\\ tT: :uzz5::.DIDII Iract|j}|jD]4}t|D]#\}}||||s|j|3yyr)rarrpop) r@rAr=r<args2arg1r;arg2r;s r<rEz all_close.._all_close_acsdUZZ JJ D$U+ 4dD$5IIaL    ra)rrMr )r@rAr=r<rDr;rEs @@@r< all_closerKs565!IJ"  huoxd CCracyr,r|rs r<rrrracDt|j|jdSr)rrr)rs r<sympify_fractionsrNs AKK 22rac*tt|Sr7rrSr2s r< sympify_mpzrQs1vracftt|jt|jSr7rrSrrr2s r< sympify_mpqrU!AKK(#amm*<==rac*tt|Sr7rPr2s r< sympify_fmpzrXrRracftt|jt|jSr7rTr2s r< sympify_fmpqrZrVracVtj||jjSr7)r _from_mpmathr\rgr2s r<sympify_mpmathr]s   Q  //racttt|j|jf\}}|t j |zzSr7)ramaprrealimagr r)rXr`ras r<sympify_complexrbs8c'AFFAFF#345JD$ !//$& &&ra)r)r)rlctjjttjjttj jt tj jtyr7)rrregisterRealrMrrrr|rar<_register_classesrfsN NNF# LL%  h' g&rar7r@)gh㈵>g:0yE>) __future__rrrrrZ containersrrrrr r r singletonr r basicrrrrrrcacherr decoratorsrintfuncrrrrrlogicrrGrsympy.external.gmpyrrrsympy.multipledispatchrru mpmath.libmplibmprr r!rercr#r$r%r&r'mpmath.ctx_mp_pythonr(mpmath.libmp.libmpfr)rlr*rmr+rkr,r-rdr.r/sympy.utilities.miscr0 parametersr1r_LOG2rDrmrprqryrrIrrrrrrrMrr RealNumberrrrSrr"r'rrr*rrrrrrrrzoorcrErrrrr rrrrrrKrNrrQrUrmpzmpqrXrZfmpzfmpqr]rbcomplexpowerrmulridentityrrlrf_illegalr|rar<rs" ,,#"'"II77+ 7$::*') jZ< e  $  }}T]]<013tn&Zn&b b ?Fb ?L?DC*7??; XvXvE hE P EdEP 'x ''g'A?iAH0/Y0f=/Y=@ y@yvyvZZd1vd1Nq&Iqfee #tJ"jIJ"Z6":6"rV*<9V*pFF?>?>BTT<.,)<.~F.F.R8/8/v<li<~Q0J)Q0hOO"^#B<D~ %3(9##$>+6T($((1+&'-8T($((1a.)* >-9T*%**Q-()/;T*%**Q*+,0-',u v '  EE1::q1113D3D Era