\hw2SSKJr SSKJr SSKJr SSKJr SSKJ r SSK J r SSK J r SSKJr SS KJr SS KJr SS KJrJr SS KJr SS KJr SSKJrJrJr SSKJ r SSK!J"r"J#r#J$r$J%r%J&r&J'r' SSK(J)r) SSK*J+r+ SSK,J-r-J.r. SSK/J0r0J1r1 SSK2J3r3 SSK4J5r5 SSK6J7r7 SSK8J9r9J:r: SSK;Jr> SSK?J@r@ SSKAJBrB SSKCJDrD SSKEJFrF SS KGJHrH "S!S"\5rIS#S$S#S#S#S%.S&jrJS'rK\BR"\I5S(5rMSS)KNJOrO SS*KPJQrQJRrRJSrS SS+KTJUrU g#),) annotations) AddWithLimits)Add)Basic)Tuple)Expr) factor_terms)diff) fuzzy_bool)Mul)oopi)Ne)S)DummySymbolWild)sympify) Piecewisesqrtpiecewise_foldtancotatan)log)floor)Abssign)MinMax) Heaviside)ratint) MatrixBase)PolyPolynomialError)FormalPowerSeries)limit)Order)shape)sympy_deprecation_warning) is_sequence) filldedentc^\rSrSr%SrSrS\S'SSjrSr\ U4Sj5r S r S r S r S rSS jrSSjrSSjrSrSrSSjrSrSrU=r$)Integral#z Represents unevaluated integral.ztuple[Expr, Tuple]argsc[US5(aUR"U0UD6$[U[5(a [ SSSS9 [ R "X/UQ70UD6nU$)aCreate an unevaluated integral. Explanation =========== Arguments are an integrand followed by one or more limits. If no limits are given and there is only one free symbol in the expression, that symbol will be used, otherwise an error will be raised. >>> from sympy import Integral >>> from sympy.abc import x, y >>> Integral(x) Integral(x, x) >>> Integral(y) Integral(y, y) When limits are provided, they are interpreted as follows (using ``x`` as though it were the variable of integration): (x,) or x - indefinite integral (x, a) - "evaluate at" integral is an abstract antiderivative (x, a, b) - definite integral The ``as_dummy`` method can be used to see which symbols cannot be targeted by subs: those with a prepended underscore cannot be changed with ``subs``. (Also, the integration variables themselves -- the first element of a limit -- can never be changed by subs.) >>> i = Integral(x, x) >>> at = Integral(x, (x, x)) >>> i.as_dummy() Integral(x, x) >>> at.as_dummy() Integral(_0, (_0, x)) _eval_Integralz integrate(Poly) and Integral(Poly) are deprecated. Instead, use the Poly.integrate() method, or convert the Poly to an Expr first with the Poly.as_expr() method. z1.6zdeprecated-integrate-poly)deprecated_since_versionactive_deprecations_target)hasattrr4 isinstancer%r+r__new__)clsfunctionsymbols assumptionsobjs Q/var/www/auris/envauris/lib/python3.13/site-packages/sympy/integrals/integrals.pyr9Integral.__new__*smT 8- . .**GC{C C h % % % */+F H##CKGK{K c UR4[URVs/sHn[U5PM sn5-$s snfN)r;tuplelimits)selfxabs r?__getnewargs__Integral.__getnewargs__ds3 %t{{(K{s{(K"LLL(Ks> c>[TU]$)a This method returns the symbols that will exist when the integral is evaluated. This is useful if one is trying to determine whether an integral depends on a certain symbol or not. Examples ======== >>> from sympy import Integral >>> from sympy.abc import x, y >>> Integral(x, (x, y, 1)).free_symbols {y} See Also ======== sympy.concrete.expr_with_limits.ExprWithLimits.function sympy.concrete.expr_with_limits.ExprWithLimits.limits sympy.concrete.expr_with_limits.ExprWithLimits.variables )super free_symbols)rF __class__s r?rLIntegral.free_symbolsgs.w##rAcURR(agSnURHKn[U5S:XdMUSUS:H=(d USUS- RnU(a gUbMISnMM URRnURHn[U5S:XaUR US5 M([U5S:Xa1USU;a(USR(a gUSRcSnUR US5 USSHnURUR5 M M URRSLaUSLaggg)NTFr"r)r;is_zerorElenrLadddiscardupdate)rFgot_nonelzfreerGis r? _eval_is_zeroIntegral._eval_is_zeros7 == A1v{qTQqT\;qtad{&;&;Y#H }}));;C3x1}Q 3x1}Qt!3q6>>V^^+#H LLQ W ANN+ == E )h%.?/@ )rAc ^^^[S5mURRUR5n[ U5S:a[ SUR-5eU(aUR 5OTnX@R;aU$[U5n[U[5(acURn[ U5S:Xa[ [S55e[ U5S:a[ [S55eUR 5nOSUup&XbR;a[ [S55e[U[5(d[ [SU-55eUR(a#UR(aURX05$UR(dUR(d [ S 5eXd:Xa4URXRUT5T45RTU05$X`R ;a[ [S 55eSS KJn UR(dQURUT5/mU"X!- US S 9nU(d [ S5eUV s/sHoRUT5PM n n OURUT5/n SSKJn U "X!- 5upURU R+5VVs/sHupX4PM snn5nU"U U5Vs/sHnURU 5PM nnU(d [ S5eUV s/sHoRUT5PM sn mU V s1sH@n UR,RXI5U R/T5-RTU5iMB nn [ U5S:a[ [S55eUR 5nU4SjmUU4Sjn/nUR HnUSnUU:Xa[ U5S:XaMUSSunnU"UU5U"UU5nn[1UU- S:5(aUUnnU*nUR3UUU45 Mj[ U5S:Xa!U"USS5nUR3UU45 MUR3U5 MUR3U5 M UR4"U/UQ76$s sn fs snnfs snfs sn fs sn f)ag Performs a change of variables from `x` to `u` using the relationship given by `x` and `u` which will define the transformations `f` and `F` (which are inverses of each other) as follows: 1) If `x` is a Symbol (which is a variable of integration) then `u` will be interpreted as some function, f(u), with inverse F(u). This, in effect, just makes the substitution of x with f(x). 2) If `u` is a Symbol then `x` will be interpreted as some function, F(x), with inverse f(u). This is commonly referred to as u-substitution. Once f and F have been identified, the transformation is made as follows: .. math:: \int_a^b x \mathrm{d}x \rightarrow \int_{F(a)}^{F(b)} f(x) \frac{\mathrm{d}}{\mathrm{d}x} where `F(x)` is the inverse of `f(x)` and the limits and integrand have been corrected so as to retain the same value after integration. Notes ===== The mappings, F(x) or f(u), must lead to a unique integral. Linear or rational linear expression, ``2*x``, ``1/x`` and ``sqrt(x)``, will always work; quadratic expressions like ``x**2 - 1`` are acceptable as long as the resulting integrand does not depend on the sign of the solutions (see examples). The integral will be returned unchanged if ``x`` is not a variable of integration. ``x`` must be (or contain) only one of of the integration variables. If ``u`` has more than one free symbol then it should be sent as a tuple (``u``, ``uvar``) where ``uvar`` identifies which variable is replacing the integration variable. XXX can it contain another integration variable? Examples ======== >>> from sympy.abc import a, x, u >>> from sympy import Integral, cos, sqrt >>> i = Integral(x*cos(x**2 - 1), (x, 0, 1)) transform can change the variable of integration >>> i.transform(x, u) Integral(u*cos(u**2 - 1), (u, 0, 1)) transform can perform u-substitution as long as a unique integrand is obtained: >>> ui = i.transform(x**2 - 1, u) >>> ui Integral(cos(u)/2, (u, -1, 0)) This attempt fails because x = +/-sqrt(u + 1) and the sign does not cancel out of the integrand: >>> Integral(cos(x**2 - 1), (x, 0, 1)).transform(x**2 - 1, u) Traceback (most recent call last): ... ValueError: The mapping between F(x) and f(u) did not give a unique integrand. transform can do a substitution. Here, the previous result is transformed back into the original expression using "u-substitution": >>> ui.transform(sqrt(u + 1), x) == i True We can accomplish the same with a regular substitution: >>> ui.transform(u, x**2 - 1) == i True If the `x` does not contain a symbol of integration then the integral will be returned unchanged. Integral `i` does not have an integration variable `a` so no change is made: >>> i.transform(a, x) == i True When `u` has more than one free symbol the symbol that is replacing `x` must be identified by passing `u` as a tuple: >>> Integral(x, (x, 0, 1)).transform(x, (u + a, u)) Integral(a + u, (u, -a, 1 - a)) >>> Integral(x, (x, 0, 1)).transform(x, (u + a, a)) Integral(a + u, (a, -u, 1 - u)) See Also ======== sympy.concrete.expr_with_limits.ExprWithLimits.variables : Lists the integration variables as_dummy : Replace integration variables with dummy ones dr"z F(x) can only contain one of: %srz* f(u) cannot be a constantz When f(u) has more than one free symbol, the one replacing x must be identified: pass f(u) as (f(u), u)z Expecting a tuple (expr, symbol) where symbol identified a free symbol in expr, but symbol is not in expr's free symbols.za Expecting a tuple (expr, symbol) but didn't get a symbol; got %szeither x or u must be a symbolz{ u must contain the same variable as in x or a variable that is not already an integration variable)solveF)checkz%no solution for solve(F(x) - f(u), x))posifyz%no solution for solve(F(x) - f(u), u)z[ The mapping between F(x) and f(u) did not give a unique integrand.c>URTU5nU[RLd URSLa*UR(a[ [ U5U-TU5$U$)Y replace d with a, using subs if possible, otherwise limit where sign of b is considered F)subsrNaN is_finiter(r)Fabwokr_s r? _calc_limit_1)Integral.transform.._calc_limit_1TsL &&A,Caee|s}}5!++T!WQY1--JrAc >[TVs1sH nT"X U5iM sn5n[U5S:a[[S55eUS$s snf)rdr"z_ The mapping between F(x) and f(u) did not give a unique limit.r)listrS ValueErrorr-)rirjFiavalsrhrls r? _calc_limit'Integral.transform.._calc_limit^sY A>Ab-q1A>?E5zA~ -(")**8O ?sA rPNrQ)rrL intersection variablesrSrppoprr8rr-r is_Symbolxreplace transformrerEsympy.solvers.solversr`sympy.simplify.simplifyrbitemsr;r r appendfunc)rFxuxfreexvarufreeuvarr`solnfifrbpdiffrepskvpuvarsnewfuncsnewfuncrs newlimitsrGsymrirjrhrlr_s @@@r?rzIntegral.transformsRN #J++DNN; u:>2T^^CE E#uyy{ ~~ %K AJ a  NNE5zQ --".//5zA~ ->"?@@99;DGA>>) -"dF++ -$&*-+",-- ;;1;;==!( ({{1;;=> > <>>!ffT1oq%9:CCQIN N ;; Z)IJK K 0{{a!AE2D !HII,01Dbq!DA1Aa!A 6 -KEII$**,?,$!v,?@E*/u*=>*=QAFF4L*=D> !HII,01Dbq!D1A34523B]]''1"''!*<$q$-(23 5 x=1 Z)#$% %,,.   ;;Ca&Cd{s8q=qr7DAq&q!,k!Q.?qA!!a%!),, !1#*($$dAq\2X]#CFA.A$$dAY/$$T*  %!$yy-9--y2 @>25s"R&R+ %R1R6:AR;c ^^^0^1^2^3^4TRSS5(dT$TRSS5nTRSS5m2TRSS5m0TRSS5nTRS S5nTRS S5n[[[SUT2X44555S :a [ S 5eU(aS =m2=p4O(T2(aS =n=p4OU(aS =n=m2nO U(aS =n=m2nT2X5UT0S.nT0S;a[ ST0-5eU(a,[ STR 55(a [ S5eTR(a[R$SSK J n [TRU5(a[ U4SjTR55(a [ S5e[ STRR SS S55(aT$TnTRn U R"UR"U R/UR Q76R!5/U R Q76R!5$TRn U R#SS5n U(aU R "S.0TD6n U R(a[R$[U [$5(aU R'UU4Sj5$[U [(5(af[TR 5S :a[*eTR Sn [U 5S :aU R,"U 40UD6$U R,"U S40UD6$0n TR Hn [U 5S:waMU um4pX4n[/SU55(aT4R0(d [3SS9nOf[/SU55(aT4R4(d [3SS9nO4[/S U55(aT4R6(d [3SS!9nOSnU(dMUU T4'M U (aU R95VVs0sH unnUU_M nnnTR;U 5R "S.0TD6n[U[<5(a-[=UVs/sHnUR;U5PM sn5nU$UR;U5nU$/n[?5nTR GHn [U 5S :Xa[?U SS 5m3OY[U 5S":XaU S R@m3O:[U 5S:Xa+U S R@RCU S"R@5m3U SU;d[ U34S#jU55(a_UREU 5 URGT35 TR"U /U /-6n U RI5n[U[J5(dUn MU RM[N[P5(a[U 5S:a[/S$U 55(d)[U 5S:Xab[/S%U S S55(aH[3S&SS!9nU R;U SU05RS[T5R;UU S05n O4U RM[V[X5(aU RS[T5n U RM[T5(a [U [T5(d [[U 5n [U [T5(a>[U 5S :XaU R\"U S40UD6nGOTR\"XS40UD6nOU0U2U4S'jnT2nT2S La[U 5S:XaU S R^(a}U S"R^(aiU R`(dXU S RM[b[b*5(d#U S"RM[b[b*5(aU"X5nUbUn GM!S nUS LaT2SLaSnO.TR\"XS40UD6nUcT2SLaU"X5nUbUn GM^TRS(S5nU(Ga[U[J5(GdUGbURe[f5GHqnURhSn U Re[j5Hn![3S)5n"U RmU!U"5n#U#RoU"5n$U"U$R@;dMCU!RhSn URmU[qU[QU$5[r-[uU [rS"- - [r- 5-55nM U Re[v5Hn%[3S)5n"U RmU%U"5n&U&RoU"5n$U"U$R@;dMCU%RhSn URmU[qU[QU$5[r-[uU [r- 5-55nM GMt Uc]UREU 5 TR"U /U /-6RI5n U RI5n[U[J5(dUn GM}[U 5S :XaUn GM[U 5S:XaU um4pO[U 5S":XaU um4nSn O[*eU(aN[U [x5(aU R "S.0TD6n [U[x5(aUR "S.0TD6nUR`(aW[URz5n'U'R}T45 UR5nURT4X5n [U /U'Q76n GMS*m1U14S+jn(///n+n*n)[pR"U5Hn,[ U1U44S,j[R"U,555(aU)REU,5 ME[ S-[R"U,555(aU+RE[[U,55 MU*REU,5 M [qU)V,s/sH n,U("U,T4X5PM sn,6n-[qU*6RT4X5n.[[[qU+65RT4X5n/U-U.-U/-n GM U $s snnfs snfs sn,f![*aU UREU 5 TR"U /U /-6n U RI5n[U[J5(dUn GMGMf=f)/a Perform the integration using any hints given. Examples ======== >>> from sympy import Piecewise, S >>> from sympy.abc import x, t >>> p = x**2 + Piecewise((0, x/t < 0), (1, True)) >>> p.integrate((t, S(4)/5, 1), (x, -1, 1)) 1/3 See Also ======== sympy.integrals.trigonometry.trigintegrate sympy.integrals.heurisch.heurisch sympy.integrals.rationaltools.ratint as_sum : Approximate the integral using a sum integralsTdeepmeijergNconds piecewiserischheurischmanualr"z;At most one of manual, meijerg, risch, heurisch can be TrueFrrrrr)separaternonez=conds must be one of "separate", "piecewise", "none", got: %sc3># UHn[U5S:v M g7f)r"N)rS).0rGs r? Integral.doit..s=#SAsz4risch=True is only allowed for indefinite integrals.rSumc3Z># UH oTRRS;v M" g7frN)r;rE)rrrFs r?rrs#HA ,,Q//s(+z3Limit of the sum cannot be an integration variable.c38# UHoRv M g7frC) is_infinite)rrXs r?rrsF*EQ==*EcZ[U[5=(a URSS-S:g$)Nr"rQ)r8r!r2rs r?Integral.doit..s$jI.C166!9Q;!3CCrAc2[URS5$Nr)r!r2rs r?rrsiq *rAc^>TR"U/TRQ76R"S0TD6$)Nr1)rrEdoit)rhintsrFs r?rrs%$))A4 499BEBrArPc38# UHoRv M g7frC)is_nonnegativerr[s r?rrs/Q##Qr)positivec38# UHoRv M g7frC)is_nonpositivers r?rrs1q!%%qr)negativec38# UHoRv M g7frC)is_realrs r?rrs*1YYr)realrQc32># UH oST;v M g7frr1)rrulis r?rrs#GAaDCKsc38# UHoRv M g7frC)is_extended_realrrs r?rrs%F#Q&8&8#rc3j# UH)nUR=(a UR(+v M+ g7frC)rrrs r?rrs,'()'9'9'O!-->O'Os13xrcb>Sn[U5S:XaT SLazUup4n[XXE5nUbeUupxT S:Xa!T R XXE45n [ Xx4U S4SS9$T S:Xa2[T R 5S:wa[[S 55eXx4nU$UnU$![a [S5 SnNf=f) NrPF+NotImplementedError from meijerint_definiterT)evaluaterr"z conds=separate not supported in multiple integrals) rSmeijerint_definiteNotImplementedError_debugrrrErpr-) r;rGretrrirjresrcondrrrrFs r? try_meijerg"Integral.doit..try_meijerg8sC3x1})="%a'"4X!"GC ?&)GA$ 3$(IIhA $B (1!QI-2(4!4!&*!4#&t{{#3q#8*4ZA>6?+@%@'(gJ'(J- 3'"$:;"&C's BB.-B.finalx1cp^[U[5=(a [U4SjUR55$)Nc3.># UH oT4:Hv M g7frCr1)rr[rs r?r6Integral.doit..is_indef_int..s'D8aaT 8s)r8r/anyrE)grs `r? is_indef_int#Integral.doit..is_indef_ints+$.q($;%E$''D188'D$DFrAc>/n[R"U5HDnT"XQ5(a#URURXU55 M3URU5 MF [U6$rC)r make_argsr~_eval_interval)rrrirjr2rrs r? eval_factored$Integral.doit..eval_factoredsX$&D%(]]1%5#/#5#5$(KK0@0@q0I$J$(KKN &6 $':-rAc36># UHnT"UT5v M g7frCr1)rrrrs r?rrs"#>,&09%=%=.>sr1)DgetrSrofilterrprrErRrZerosympy.concrete.summationsrr8r;rvrrreplacer$ applyfuncr'r integrateallrrrrr}ryrDsetrLunionr~rVfactorr/hasrrrewriterrr r_eval_integralris_Polyr atomsrr2rrer rrrrrgensremoveas_exprrr%rr )5rFrrrrr eval_kwargsr_i_sumr;rGrrirjrXr_rrundodidr[ undone_limitsuljfactored_functionr antiderivrmeijerg1rr atan_termatan_argtan_partrtan_exp1coeffcot_partcot_exp1rrrothers piecewisesrunevalevalued evalued_pwrrrrrs5`` @@@@@r?r Integral.doitsX *yyd++Kyy&))It, ';/ '4(99Z.8T* tF4&'5!CDE F JZ[ [ ). .G .eh (- -F -UX */ /F /Wx ', ,F ,Wu")EYa  9 9/1678 8 S====ST T <<66M 2 dmmS ) )HHHH !VWWF$--*>*>q*A!"*EFFF B==D99RWWT]]?RYY?DDFUUZZ\ \==## C *, }}-u-H   66M h + +%%BD D h 1 2 24;;!#))++a.C3x!|))#===))#a&@K@@;;C3x1}GAqA/Q///8H8H4(1q111!:J:J4(****199t$qQ+, %)ZZ\2\TQAqD\D2--%**3U3C#u%%s;s!QZZ-s;<Jll4(J e;;C3x1}#bq'lSQ!f))SQ!f))//A0C0CD 1v}#G#G G G$$S) 399zSE'9;$,OO$5!!"3X>>0H||C&&SA#%F#%F"F"FSQ3'!"g'$$t$/B ( 1 13q62, ? +HHb#a&\,Bc3''#++I6 Y''x33-h7H(I..s8q= ( 7 7A!'%!'I!% 3 3 a&!9,7!9I<#5(CA #a&*A*Ac!fF]F] ( 0 0QB,,A 2s0C0C%h4C#& $Hu$D $I $ 3 3 a&!9,7!9I (W_)(8?'*H$IIgt,EjH==%!*!6I(~~a0H$,NN3$7"4[#+==2#> ( b 1U%7%77 ( a 0A(1y#i $U Bua1fb[/A ACC)DI%8%-NN3$7"4[#+==2#> ( b 1U%7%77 ( a 0A(1y#i $U BuaV} <C>)?I%8"7, $$S)99zSE'9;BBD$,OO$5!!"3X>>0Hs8q=(H3x1}"%1aSQ"1 11%a// !A%a// !A ((#INN3 A$-$5$5$7 #,#;#;Aq#D#'#84#8F .9;B:6 !$y!9A"#>,/MM!,<#> > > ) 0 0 3!$%@.1mmA.>%@"@"@ * 1 1.2C D & a 0":"%09';091(5Q1'@09';"< =&)6l&A&A!Q&JG)7Z8H)I)X)XYZ\])aJ'-'7*'DHUf3<\'; 3=*005'+yyH:3E'GH080A-#-.?#J#J+<$K =s&>rr.r ArAs>=s>cn^^^ TR[TR5p2URS5n[ U5S:XaUum pVO[ U5S:XaUum nSnOS=pVUSm U(aTR "U/[ U5Q76nUUU 4Sjn[RnUb X"X&5- nUb X"X%5-n[ U5S:XaTT :XaUn X- nU$[S5n URT U 5RT5RU T 5n U (aUTR U T XV45- nU$) aEvaluate the derivative of the current Integral object by differentiating under the integral sign [1], using the Fundamental Theorem of Calculus [2] when possible. Explanation =========== Whenever an Integral is encountered that is equivalent to zero or has an integrand that is independent of the variable of integration those integrals are performed. All others are returned as Integral instances which can be resolved with doit() (provided they are integrable). References ========== .. [1] https://en.wikipedia.org/wiki/Differentiation_under_the_integral_sign .. [2] https://en.wikipedia.org/wiki/Fundamental_theorem_of_calculus Examples ======== >>> from sympy import Integral >>> from sympy.abc import x, y >>> i = Integral(x + y, y, (y, 1, x)) >>> i.diff(x) Integral(x + y, (y, x)) + Integral(1, y, (y, 1, x)) >>> i.doit().diff(x) == i.diff(x).doit() True >>> i.diff(y) 0 The previous must be true since there is no y in the evaluated integral: >>> i.free_symbols {x} >>> i.doit() 2*x**3/3 - x/2 - 1/6 rPrQNrcR>[UT5nU(d[R$[U[5(aUUR Vs/sH!n[ U5S:Xa UST:XaTT4OUPM# nnTR"UR/UQ76nURTU5U-$s snfNr"r) r rrr8r/rErSrr;re)rabdab_dsymrXrErFrrs r?_do&Integral._eval_derivative.._dosB}Hvv !X&&#$88-#+a&)Vq[QqTQY1a&QF#+-IIajj26266!R=) )-s(B$r"r) r;rorErwrSrrDrrrrer ) rFrrrEr(rirjrrvargrrs `` @r?_eval_derivativeIntegral._eval_derivatives-ZMM4 #46 2 u:?GAq! Z1_DAqALAaA  !,eFm,A *VV = #a)OB = #a)OB u:?saxC IB c A&&A,##C(--a3CdiiaY// rAc SSKJn Jn SSKJn U(aU "XUS9$U(a"U "X5n U bU R [:waU $X4UXgS.n [U[5(a&U(dU(dU(dURU5$[U[5(aUR"U40U D6$URU5(dX-$UR!U5nUb3U(d,U(d%U(dUR5R#5$USLa@U "XSUS 9upU(a,U S:XaU "X5R%SS 9$XR%SS 9-$U $SS KJn /n[*R,"U5nUGHnUR/U5unnU[0R2LaU(dUR5UU-5 MHUR75nUb~UR8"UR;5U40U D6nUbWUR8"UR<U40U D6nUb6UR "U/UR>Q76nUR5UUU--5 M gUR@(Ga>URBRU5(GdU(Gd[ES U/S 9n[ESU/S 9nURFRIUU-U-5nUbURBS:Xa[KURF5nOUS:wa-URFURBS--URBS-- nOe[KURF5nURFURBS--URBS-- n[U[MURBS54US45nUR5UU-UU- 5 GM)UROU5(a6U(d/U(d(U(d!UR5U[QUU5-5 GMuU(dU(dU(d[SUX'S9nUbUR5UU-5 GM[UUU5nUbUR5UU-5 GMSSK+J,n U"UU5nUbUR5UU-5 GMUSLa=U "UUSUS 9unnU(aUUR%SS 9-nUR5UU-5 GM?USLa!SSK-J.nJ/n US:Xa U "UU/S9nO U"UU/S9nOOSnUSLa*Uc'[aUU5nUbUR5UU-5 GMUcUSLaU "UU5n U b[U [5(dU R[5(ayU(drU n!SU!S'SU!S'U R "U RdV"s/sH1n"U"R[5(aU"R$"S0U!D6OU"PM3 sn"6RgSSSSS9n U R[5(dUR5UU -5 GMU(dK[iU5S:Xa<U"U5RgSSS9nURj(aUR8"X40U D6s $UbUR5UU-5 GM g [+U6$![ a gf=f![[4a GNOf=f![ a GNQf=f![ a SnGNf=f![a SnGNf=f![ a [cS5 GNf=fs sn"f![[4a GN f=f)a Calculate the anti-derivative to the function f(x). Explanation =========== The following algorithms are applied (roughly in this order): 1. Simple heuristics (based on pattern matching and integral table): - most frequently used functions (e.g. polynomials, products of trig functions) 2. Integration of rational functions: - A complete algorithm for integrating rational functions is implemented (the Lazard-Rioboo-Trager algorithm). The algorithm also uses the partial fraction decomposition algorithm implemented in apart() as a preprocessor to make this process faster. Note that the integral of a rational function is always elementary, but in general, it may include a RootSum. 3. Full Risch algorithm: - The Risch algorithm is a complete decision procedure for integrating elementary functions, which means that given any elementary function, it will either compute an elementary antiderivative, or else prove that none exists. Currently, part of transcendental case is implemented, meaning elementary integrals containing exponentials, logarithms, and (soon!) trigonometric functions can be computed. The algebraic case, e.g., functions containing roots, is much more difficult and is not implemented yet. - If the routine fails (because the integrand is not elementary, or because a case is not implemented yet), it continues on to the next algorithms below. If the routine proves that the integrals is nonelementary, it still moves on to the algorithms below, because we might be able to find a closed-form solution in terms of special functions. If risch=True, however, it will stop here. 4. The Meijer G-Function algorithm: - This algorithm works by first rewriting the integrand in terms of very general Meijer G-Function (meijerg in SymPy), integrating it, and then rewriting the result back, if possible. This algorithm is particularly powerful for definite integrals (which is actually part of a different method of Integral), since it can compute closed-form solutions of definite integrals even when no closed-form indefinite integral exists. But it also is capable of computing many indefinite integrals as well. - Another advantage of this method is that it can use some results about the Meijer G-Function to give a result in terms of a Piecewise expression, which allows to express conditionally convergent integrals. - Setting meijerg=True will cause integrate() to use only this method. 5. The "manual integration" algorithm: - This algorithm tries to mimic how a person would find an antiderivative by hand, for example by looking for a substitution or applying integration by parts. This algorithm does not handle as many integrands but can return results in a more familiar form. - Sometimes this algorithm can evaluate parts of an integral; in this case integrate() will try to evaluate the rest of the integrand using the other methods here. - Setting manual=True will cause integrate() to use only this method. 6. The Heuristic Risch algorithm: - This is a heuristic version of the Risch algorithm, meaning that it is not deterministic. This is tried as a last resort because it can be very slow. It is still used because not enough of the full Risch algorithm is implemented, so that there are still some integrals that can only be computed using this method. The goal is to implement enough of the Risch and Meijer G-function methods so that this can be deleted. Setting heurisch=True will cause integrate() to use only this method. Set heurisch=False to not use it. r)risch_integrateNonElementaryIntegral)manualintegrate)rNrFT)separate_integralr)r) sincos_to_sumri)excluderjr rr")singularityintegrate)rheurisch_wrapper)rrrr) multinomialr power_exp power_base)mulrr1)6sympy.integrals.rischrrsympy.integrals.manualintegraterrrr/rpr&r8r%rrpiecewise_integrateras_polyrrsympy.simplify.furrras_independentrOner~getOrremoveOexprrvis_Powexprbasematchrris_rational_functionr# trigintegratedeltaintegratesingularityfunctionsrsympy.integrals.heurischrrmeijerint_indefiniterr2expandrSis_Add)#rFrrrrrrrrrrrresultrpolyr[rpartsr2rr order_termh h_order_expr h_order_termrirjMh1h2r heurisch_rnew_eval_kwargsrs# r?rIntegral._eval_integral7sx QC  &q599  (.%&++*A!M#*V 2  a  'U;;q> ! a # #((:k: :uuQxx3Jyy|  Vw%>>#++- -   "+AD!   {4Q:??e?LL%U(;;;!M 4}}QA''*HE1AEEz' U1W%J%'' QF+F=#'#6#6z#Y[#YL#/'1((A+5+?+?(A  UA ,<%=> xxx ! Wqc*qc*FFLL1q)=uu{K+-FFQUUQY/15519= [VVaeeai0AEEAI>%r2aeeR=&9B:FLLQqT!12 %%a((&Gu UVAq\12g!!Q4=LL+#1a(=LL+F(A.=LL+% !.q!.2% A1  !AFFF$7 7A U1W- 5(L ! K/ 0AR @A )!Qb 9A)e# J,Q2A=LL+yV50,Q2F)*VX2N2N!::h// /:O8=OH57Z>' [A([2>8[- 6A[23 Z?ZZZ Z('Z(+ Z;:Z;> [ [[*)[*-[22\\c## UR5nUnURHnXSS;dM USn O URRXR5Hn[ U/URQ76v M g7fr )as_dummyrEr;lseriesr)rFrlogxcdirr,symbrXterms r? _eval_lseriesIntegral._eval_lseriessi}}AabEztMM))$5DD/4;;/ /6s (A2AA2c6UnURHnXSS;dM USn O URRXRUS9R[5upxUV s/sHoR XQ5PM nn [ U/URQ76[U6U--$s sn f)Nr"r)rnrI)rEr;nseries as_coeff_addr)rerr) rFrrPrIrJrKrXtermsorderos r? _eval_nseriesIntegral._eval_nseriessAabEzt}},,d-$$0L$7 */0%Q%0--U A ==1sBcURSRU5nUH nUS:wdM O [W/URSSQ76$)Nrr")r2rHr)rFrrIrJ series_gen leading_terms r?_eval_as_leading_termIntegral._eval_as_leading_termsKYYq\))!, &Lq '6 !" 66rAc [U5n[U[5(a6SSKJn UR "UR Vs/sH oC"U40UD6PM sn6$UR"S0UD6$s snf)Nr)simplifyr1)r r8r/r|r^rr2)rFkwargsr,r^r[s r?_eval_simplifyIntegral._eval_simplifys`D! dH % % 899diiHix4V4iHI I}}&v&&IsA)c SSKJn URn[U5S:a [ S5eUSn[U5S:wd$USR SLdUSR SLa [ S5eUc [S S S S 9nO [U5nURSLdURSLdUR SLa[ S U-5eUupxn X- U- n [S S S S 9n URn US:Xa'X"U RXxU S- U --5U SU45-n OUS:Xa#X"U RXxX--5U SU45-n OUS:Xa)X"U RXxX--U S- - 5U SU45-n OaUS:XaMXRXx5U RXy5-S- U"U RXxX--5U SUS- 45--n O[ SU-5eU(aU R5$U $)a Approximates a definite integral by a sum. Parameters ========== n : The number of subintervals to use, optional. method : One of: 'left', 'right', 'midpoint', 'trapezoid'. evaluate : bool If False, returns an unevaluated Sum expression. The default is True, evaluate the sum. Notes ===== These methods of approximate integration are described in [1]. Examples ======== >>> from sympy import Integral, sin, sqrt >>> from sympy.abc import x, n >>> e = Integral(sin(x), (x, 3, 7)) >>> e Integral(sin(x), (x, 3, 7)) For demonstration purposes, this interval will only be split into 2 regions, bounded by [3, 5] and [5, 7]. The left-hand rule uses function evaluations at the left of each interval: >>> e.as_sum(2, 'left') 2*sin(5) + 2*sin(3) The midpoint rule uses evaluations at the center of each interval: >>> e.as_sum(2, 'midpoint') 2*sin(4) + 2*sin(6) The right-hand rule uses function evaluations at the right of each interval: >>> e.as_sum(2, 'right') 2*sin(5) + 2*sin(7) The trapezoid rule uses function evaluations on both sides of the intervals. This is equivalent to taking the average of the left and right hand rule results: >>> s = e.as_sum(2, 'trapezoid') >>> s 2*sin(5) + sin(3) + sin(7) >>> (e.as_sum(2, 'left') + e.as_sum(2, 'right'))/2 == s True Here, the discontinuity at x = 0 can be avoided by using the midpoint or right-hand method: >>> e = Integral(1/sqrt(x), (x, 0, 1)) >>> e.as_sum(5).n(4) 1.730 >>> e.as_sum(10).n(4) 1.809 >>> e.doit().n(4) # the actual value is 2 2.000 The left- or trapezoid method will encounter the discontinuity and return infinity: >>> e.as_sum(5, 'left') zoo The number of intervals can be symbolic. If omitted, a dummy symbol will be used for it. >>> e = Integral(x**2, (x, 0, 2)) >>> e.as_sum(n, 'right').expand() 8/3 + 4/n + 4/(3*n**2) This shows that the midpoint rule is more accurate, as its error term decays as the square of n: >>> e.as_sum(method='midpoint').expand() 8/3 - 2/(3*_n**2) A symbolic sum is returned with evaluate=False: >>> e.as_sum(n, 'midpoint', evaluate=False) 2*Sum((2*_k/n - 1/n)**2, (_k, 1, n))/n See Also ======== Integral.doit : Perform the integration using any hints References ========== .. [1] https://en.wikipedia.org/wiki/Riemann_sum#Riemann_summation_methods rrr"z2Multidimensional midpoint rule not implemented yetrPFrQz5Expecting a definite integral over a finite interval.rPT)integerrz$n must be a positive integer, got %srleftrightmidpoint trapezoidzUnknown method %s)rrrErSrrgrprr is_positive is_integerr;rer)rFrPmethodrrrEr(rrirjdxrrr9s r?as_sumIntegral.as_sumsR 2 v;?%DF F1IEE a58#5#5#>a""e+ "788 9c4$7A A MMU "alle&; KK5 CaGH HaeQY #td 3 MM V AFF11Q3(l3aAY??F w AFF1!$h/!Q;;F z !AFF1!$hAo6Aq BBF { "&&,5q8AFF1!$h'!QA789F069: : (v{{}4f4rAc [UR5S:wd%[[URS55S:wa [S5eURSup#nUR(aUR(aX4::d [S5eX4:Xa[ R $SSKJn [S5nURnU"Xr5Vs/sH)oR(dMX8s=::aU::dM#O M'UPM+ n nU Hn XU4;dM [SU -5e [Xr40UD6n U R[5(aU$U[*La-U[La$[XR!X"*5- U[5n O[XUS 5[XUS 5- n U H;nU [U R!X(U- 5U R!X(U-5- USS 5- n M= U $s snf) a Compute the Cauchy Principal Value of the definite integral of a real function in the given interval on the real axis. Explanation =========== In mathematics, the Cauchy principal value, is a method for assigning values to certain improper integrals which would otherwise be undefined. Examples ======== >>> from sympy import Integral, oo >>> from sympy.abc import x >>> Integral(x+1, (x, -oo, oo)).principal_value() oo >>> f = 1 / (x**3) >>> Integral(f, (x, -oo, oo)).principal_value() 0 >>> Integral(f, (x, -10, 10)).principal_value() 0 >>> Integral(f, (x, -10, oo)).principal_value() + Integral(f, (x, -oo, 10)).principal_value() 0 References ========== .. [1] https://en.wikipedia.org/wiki/Cauchy_principal_value .. [2] https://mathworld.wolfram.com/CauchyPrincipalValue.html r"rrPzkYou need to insert a variable, lower_limit, and upper_limit correctly to calculate cauchy's principal valuezThe lower_limit must be smaller than or equal to the upper_limit to calculate cauchy's principal value. Also, a and b need to be comparable.) singularitiesrzRThe principal value is not defined in the given interval due to singularity at %d.-+)rSrErorp is_comparablerrsympy.calculus.singularitiesrorr;rrr/r r(re) rFr_rrirjrorprrsingularities_listr[rhIs r?principal_valueIntegral.principal_value>s@ t{{ q CT[[^(<$=$B89 9++a.aAOO^_ _ 666M> #J MM)6q)<`)BUn 0 >7'K5Z<<rAr/Nr)rrrrrc&SUUUUUS.n[U0UD6n[U[5(aUR"S0UD6$URV s/sH,n [U [5(aU R"S0UD6OU PM. n n UR"U 6$s sn f)aintegrate(f, var, ...) .. deprecated:: 1.6 Using ``integrate()`` with :class:`~.Poly` is deprecated. Use :meth:`.Poly.integrate` instead. See :ref:`deprecated-integrate-poly`. Explanation =========== Compute definite or indefinite integral of one or more variables using Risch-Norman algorithm and table lookup. This procedure is able to handle elementary algebraic and transcendental functions and also a huge class of special functions, including Airy, Bessel, Whittaker and Lambert. var can be: - a symbol -- indefinite integration - a tuple (symbol, a) -- indefinite integration with result given with ``a`` replacing ``symbol`` - a tuple (symbol, a, b) -- definite integration Several variables can be specified, in which case the result is multiple integration. (If var is omitted and the integrand is univariate, the indefinite integral in that variable will be performed.) Indefinite integrals are returned without terms that are independent of the integration variables. (see examples) Definite improper integrals often entail delicate convergence conditions. Pass conds='piecewise', 'separate' or 'none' to have these returned, respectively, as a Piecewise function, as a separate result (i.e. result will be a tuple), or not at all (default is 'piecewise'). **Strategy** SymPy uses various approaches to definite integration. One method is to find an antiderivative for the integrand, and then use the fundamental theorem of calculus. Various functions are implemented to integrate polynomial, rational and trigonometric functions, and integrands containing DiracDelta terms. SymPy also implements the part of the Risch algorithm, which is a decision procedure for integrating elementary functions, i.e., the algorithm can either find an elementary antiderivative, or prove that one does not exist. There is also a (very successful, albeit somewhat slow) general implementation of the heuristic Risch algorithm. This algorithm will eventually be phased out as more of the full Risch algorithm is implemented. See the docstring of Integral._eval_integral() for more details on computing the antiderivative using algebraic methods. The option risch=True can be used to use only the (full) Risch algorithm. This is useful if you want to know if an elementary function has an elementary antiderivative. If the indefinite Integral returned by this function is an instance of NonElementaryIntegral, that means that the Risch algorithm has proven that integral to be non-elementary. Note that by default, additional methods (such as the Meijer G method outlined below) are tried on these integrals, as they may be expressible in terms of special functions, so if you only care about elementary answers, use risch=True. Also note that an unevaluated Integral returned by this function is not necessarily a NonElementaryIntegral, even with risch=True, as it may just be an indication that the particular part of the Risch algorithm needed to integrate that function is not yet implemented. Another family of strategies comes from re-writing the integrand in terms of so-called Meijer G-functions. Indefinite integrals of a single G-function can always be computed, and the definite integral of a product of two G-functions can be computed from zero to infinity. Various strategies are implemented to rewrite integrands as G-functions, and use this information to compute integrals (see the ``meijerint`` module). The option manual=True can be used to use only an algorithm that tries to mimic integration by hand. This algorithm does not handle as many integrands as the other algorithms implemented but may return results in a more familiar form. The ``manualintegrate`` module has functions that return the steps used (see the module docstring for more information). In general, the algebraic methods work best for computing antiderivatives of (possibly complicated) combinations of elementary functions. The G-function methods work best for computing definite integrals from zero to infinity of moderately complicated combinations of special functions, or indefinite integrals of very simple combinations of special functions. The strategy employed by the integration code is as follows: - If computing a definite integral, and both limits are real, and at least one limit is +- oo, try the G-function method of definite integration first. - Try to find an antiderivative, using all available methods, ordered by performance (that is try fastest method first, slowest last; in particular polynomial integration is tried first, Meijer G-functions second to last, and heuristic Risch last). - If still not successful, try G-functions irrespective of the limits. The option meijerg=True, False, None can be used to, respectively: always use G-function methods and no others, never use G-function methods, or use all available methods (in order as described above). It defaults to None. Examples ======== >>> from sympy import integrate, log, exp, oo >>> from sympy.abc import a, x, y >>> integrate(x*y, x) x**2*y/2 >>> integrate(log(x), x) x*log(x) - x >>> integrate(log(x), (x, 1, a)) a*log(a) - a + 1 >>> integrate(x) x**2/2 Terms that are independent of x are dropped by indefinite integration: >>> from sympy import sqrt >>> integrate(sqrt(1 + x), (x, 0, x)) 2*(x + 1)**(3/2)/3 - 2/3 >>> integrate(sqrt(1 + x), x) 2*(x + 1)**(3/2)/3 >>> integrate(x*y) Traceback (most recent call last): ... ValueError: specify integration variables to integrate x*y Note that ``integrate(x)`` syntax is meant only for convenience in interactive sessions and should be avoided in library code. >>> integrate(x**a*exp(-x), (x, 0, oo)) # same as conds='piecewise' Piecewise((gamma(a + 1), re(a) > -1), (Integral(x**a*exp(-x), (x, 0, oo)), True)) >>> integrate(x**a*exp(-x), (x, 0, oo), conds='none') gamma(a + 1) >>> integrate(x**a*exp(-x), (x, 0, oo), conds='separate') (gamma(a + 1), re(a) > -1) See Also ======== Integral, Integral.doit F)rrrrrrr1)r/r8rr2r) rrrrrr2r_ doit_flagsintegralrinew_argss r?rr~s|  J((H(H%%}}*z**]]$"-7q(,C,CAFF(Z(J" $}}h''$s 3BcPSSKJn [U5nU(d [S5e[ X5(d [S5e[ U5(d [S5e[ UR5[ U5:wa [S5eURU;a [S5eUnSn[U5HAupxURUn [XR5n XjU --nURX5nMC U[U5-n[XQR5RSS 9n U $) aQline_integrate(field, Curve, variables) Compute the line integral. Examples ======== >>> from sympy import Curve, line_integrate, E, ln >>> from sympy.abc import x, y, t >>> C = Curve([E**t + 1, E**t - 1], (t, 0, ln(2))) >>> line_integrate(x + y, C, [x, y]) 3*sqrt(2) See Also ======== sympy.integrals.integrals.integrate, Integral r)Curvez6Expecting function specifying field as first argument.z*Expecting Curve entity as second argument.z)Expecting ordered iterable for variables.z3Field variable size does not match curve dimension.z.Curve parameter clashes with field parameters.F)r)sympy.geometryrrrpr8r,rS functions parameter enumerater rerr/rEr) fieldcurvevarsrrhFtdldtr[var_f_dnrs r?line_integrater-s&%A  DF F e # #EFF t  DEE 5??s4y(NOO $IJJ B DD/ __Q 2'Sy! WWS  " d4jBLL)..E.:H OrAc,[UR5$rC)r*r;)r,s r?_ras  rA)r3)rr6r)r2)V __future__rsympy.concrete.expr_with_limitsrsympy.core.addrsympy.core.basicrsympy.core.containersrsympy.core.exprrsympy.core.exprtoolsr sympy.core.functionr sympy.core.logicr sympy.core.mulr sympy.core.numbersr rsympy.core.relationalrsympy.core.singletonrsympy.core.symbolrrrsympy.core.sympifyrsympy.functionsrrrrrr&sympy.functions.elementary.exponentialr#sympy.functions.elementary.integersr$sympy.functions.elementary.complexesrr(sympy.functions.elementary.miscellaneousrr -sympy.functions.special.singularity_functionsr! rationaltoolsr#sympy.matricesr$ sympy.polysr%r&sympy.series.formalr'sympy.series.limitsr(sympy.series.orderr)sympy.tensor.functionsr*sympy.utilities.exceptionsr+sympy.utilities.iterablesr,sympy.utilities.miscr-r/rrregisterrdeltafunctionsr3 meijerintrr6r trigonometryr2r1rAr?rs"9"' -$'%$"33&KK65:=C!%-1%$(@1+W}Wv*"D4X\m(^/h  +GG'rA