a Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGddlHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTddlUmVZVddlWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcddldmeZeddlfmgZgdd lhmiZidd!ljmkZkdd"llmmZmdd#lnmoZodd$lpmqZqdd%lrmsZsdd<muZumvZvmwZwmxZxdd'lymzZzdd(l{m|Z|d6d*d+Z}e}d,d-Z~e}d.d/Ze}d0d1Ze}d2d3Ze}d4d5Ze}d6d7Ze}d8d9Ze}d:d;Ze}dZe}d?Ze}d@d>Ze}dAdBZe}dCZe}dDZe}dEdFZe}dGdHZe}dIdJZe}dKdLZe}dMdNZe}dOdNZe}dPdNZe}dQdRZe}dSdTZe}dUdVZe}dWdVZe}dXdVZe}dYdVZe}dZdVZe}d[dTZe}d\d]Ze}d^d]Ze}d_d]Ze}d`d]Ze}dad]Ze}dbdNZe}dcdNZe}dddNZe}ded]Ze}dfd]Ze}dgdhZe}didjZe}dkdjZedldmZiZdndoZdpdqZdrdsZdtduZeDeCeBeEeFeGfZdvdwZdxdyZdzd{Zd|d}Zd~dBZddZddZddZddZddZddZddZddZddZddZddZddZddZddZeddZeddZeddZeddZeddZddZddZeddZeddZeddZeddZeddZeddZeddZeddZeddZeddZeddZeddZeddZeddZeddZeddZddZddZddZddZddÄZddńZddDŽZddɄZeddddZeddddZeddddZeddddZddӄZddՄZddׄZiZeeZe'd؃ZddڄZee~dd܄ZeeddބZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeeddZeed d Zeed d Zeed dZeeddZeeddZ eeddZ eeddZ eeddZ eeddZ eeddZeeddZeedd Zeed!d"Zeed#d$Zeed%d&Zeed'd(Zeed)d*Zeed+d,Zeed-d.Zeed/d0Zd1d2Zd3d4Zd5S(7aIntegration method that emulates by-hand techniques. This module also provides functionality to get the steps used to evaluate a particular integral, in the ``integral_steps`` function. This will return nested namedtuples representing the integration rules used. The ``manualintegrate`` function computes the integral using those steps given an integrand; given the steps, ``_manualintegrate`` will evaluate them. The integrator can be extended with new heuristics and evaluation techniques. To do so, write a function that accepts an ``IntegralInfo`` object and returns either a namedtuple representing a rule or ``None``. Then, write another function that accepts the namedtuple's fields and returns the antiderivative, and decorate it with ``@evaluates(namedtuple_type)``. If the new technique requires a new match, add the key and call to the antiderivative function to integral_steps. To enable simple substitutions, add the match to find_substitutions. )DictOptional) namedtuple defaultdict)Mapping)reduce)Add)cacheit)r)Expr) Derivative) fuzzy_not)Mul)IntegerNumberE)Pow)EqNeGtLt)S)DummySymbolWild)Abs)explog)coshsinhacoshasinhacothatanh)sqrt Piecewise) TrigonometricFunctioncossintancotcscsecacosasinatanacotacscasec) Heaviside) erferfifresnelcfresnelsCiChiSiShiEili uppergamma) elliptic_e elliptic_f) chebyshevt chebyshevulegendrehermitelaguerreassoc_laguerre gegenbauerjacobiOrthogonalPolynomialpolylogIntegral)And)divisorsdegree)fraction)simplify)solve)switchdo_one null_safe condition)iterable)debugcs2ddfdd}t||d}|_||_|S)NcSs|j|jkot||SN) __class__tuple__eq__selfotherreo/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/integrals/manualintegrate.pyraDszRule..__eq__cs || Sr^rerbrarerfFzRule..z context symbol)rra__ne__)namepropsZ__neq__clsrergrfRuleBs  rn ConstantRuleconstantConstantTimesRulezconstant other substep PowerRulezbase expAddRulesubstepsURulezu_var u_func constant substep PartsRulezu dv v_step second_stepCyclicPartsRulezparts_rules coefficientTrigRulezfunc argExpRuleReciprocalRulefunc ArcsinRuleInverseHyperbolicRuleAlternativeRule alternatives DontKnowRuleDerivativeRule RewriteRulezrewritten substep PiecewiseRuleZ subfunctions HeavisideRulezharg ibnd substepTrigSubstitutionRulez(theta func rewritten substep restriction ArctanRuleza b c ArccothRule ArctanhRule JacobiRulezn a bGegenbauerRulezn aChebyshevTRulenChebyshevURule LegendreRule HermiteRule LaguerreRuleAssocLaguerreRuleCiRuleza bChiRuleEiRuleSiRuleShiRuleErfRule FresnelCRule FresnelSRuleLiRule PolylogRuleUpperGammaRuleza e EllipticFRuleza d EllipticERule IntegralInfozintegrand symbolcsfdd}|S)Ncs|_|t<|Sr^)rule evaluatorsr{rrerf _evaluates}szevaluates.._evaluatesre)rrrerrf evaluates|s rcCsXt|trdS|D]@}t|tr0t|rRdSqt|trtdd|DrdSqdS)NTcss|]}t|VqdSr^contains_dont_know.0irererf riz%contains_dont_know..F) isinstancerr`rlistany)rvalrererfrs   rcs|jr|jd}t|tr2|t|dSt|trT| t|dSt|trx|t|t|St|tr| t|t|St|trtfdd|jDSt|t rt |jdkrt|jdt r|jdt |jdS|S)aDerivative of f in form expected by find_substitutions SymPy's derivatives for some trig functions (like cot) aren't in a form that works well with finding substitutions; this replaces the derivatives for those particular forms with something that works better. rcsg|]}t|qSre) manual_diffrargsymbolrerf rizmanual_diff..rM) argsrr)diffr,r*r+rsumr lenrr)frrrerrfrs        "rcst|dkr>|d}t|ttfr,|}qZt|sZtdnt|dkrR|g}ntdg}|D]J\}t|trb|jd| fddfdd}| t fqb| t ||S) zn A wrapper for `expr.subs(*args)` with additional logic for substitution of invertible functions. rMrz(Expected an iterable of (old, new) pairsrz$subs accepts either 1 or 2 argumentscs|jo|jkSr^)is_Powbasex)x0rerfrhrizmanual_subs..cst|jSr^)rr)newrerfrhri)rrrritemsr[ ValueErrorrrreplaceappendrsubsr)exprrsequenceZnew_subsoldre)rrrf manual_subss$        rc sg}fdd}fddD]`}|kr8q*t|}|||}|dur*|\}}|krnq*|||f} | |vr*|| q*|S)Ncsn|dkr dS|}|jvr"dStd||t||}|jvrr|rtfddD}tfdd|D}||krdS|jddSt |t rjd|j j rjt |j dkrjtd gd }td gd }|j||rjfd d||fD\}}|dkrj|dkrj|d|j ||}|jddSdS) NrFz!substituted: {}, u: {}, u_var: {}csg|]}t|qSrerRrtrrerfrriz.test_subterm..csg|]}t|qSrerRr)u_varrerfrri)Zas_AddrMaexcludebcsg|]}|tjqSregetrZerormatchrerfrri) free_symbolsr\formatrcancelis_rational_functionmaxas_numer_denomas_independentrrr is_Integerrrrrr)uu_diff substitutedZ deg_beforeZ deg_afterrr) integrandrrrrf test_subterms8   z(find_substitutions..test_subtermcsttgttttRr*jdgStttt t t frJjdgStt t frdjdgSttrzjdgSttrg}jD]}||||q|Sttrdg}jdr|jdn"jdr|jdjdjr`|fddtjdDjdjr`|ddjdD|Sttrg}jD]}||||qz|SgS)NrrMrcs<g|]4}d|kr&tjdkrnqjd|qS)rMr)absr)rdtermrerfr s"zAfind_substitutions..possible_subterms..cSsg|]}|jr|qSre)rrrererfrs)rr&inverse_trig_functionsrrr3rrBrCrDrErFrHrGrIr rextendr is_constantrrQZis_Addr)rrrr)possible_subtermsrrrfrsT         "   z-find_substitutions..possible_subtermsF)rrr) rrrresultsrrrZ new_integrandrp substitutionre)rrrrrffind_substitutionss "'     rcsfdd}|S)z$Strategy that rewrites an integrand.cs\|\}}td|||rX|}||krXt||}t|tsX|rXt||||SdS)Nz/Integral: {} is rewritten with {} on symbol: {})r\rintegral_stepsrrr)integralrr rewrittensubsteprZrewritererf _rewriter*s zrewriter.._rewriterre)rZrrrerrfrewriter(s rcsfdd}|S)zAStrategy that rewrites an integrand based on some other criteria.cs`|\}}|\}}td||||t|}|r\|}||kr\t|t||||SdS)Nz@Integral: {} is rewritten with {} on symbol: {} and criteria: {})r\rrrr)criteriarrrrrrrerf_proxy_rewriter:s z'proxy_rewriter.._proxy_rewriterre)rZrrrerrfproxy_rewriter8s rcsfdd}|S)z4Apply the rule that matches the condition, else Nonecs*D]\}}||r||SqdSr^)r)rkeyr conditionsrerfmultiplexer_rlJsz#multiplexer..multiplexer_rlre)rrrerrf multiplexerHs rcsfdd}|S)zHStrategy that makes an AlternativeRule out of multiple possible results.csg}d}tdD]L}|d}td||||}|rt|ts||kr||vr||qt|dkrv|dS|rdd|D}|rt|g|RSt|g|RSdS)NrzList of Alternative RulesrM Rule {}: {}cSsg|]}t|s|qSrer)rrrererfrariz7alternatives.._alternatives..)r\rrrrrr~)rZaltscountrresultZdoablerulesrerf _alternativesRs(  z#alternatives.._alternativesre)rrrerrfrPs cCst|jg|RSr^)rorrrererf constant_rulehsrcCs|\}}|\}}||jvrRt|trRt|ddkrDt|||St||||S||jvrt|trt||||}tt |j r|St |j rt dd|St |t t |dft dd|dfg||SdS)NrMrT) as_base_exprrrrUrzrrryr ris_zerororr)rrrrZexptrrererf power_ruleks$    r cCs0|\}}t|jdtr,tt|jd||SdSNr)rrrryr)rrrrererfexp_rulesr cstttttttttt t t t t tti}tdtdtdi}|\}|D]n}t||r@||d}|j|ur@tfdd|jd|Ds@|jd||f}|||Sq@dS)NrrrMc3s|]}|VqdSr^has)rvrrerfrriz'orthogonal_poly_rule..)rIrrHrrBrrCrrDrrErrFrrGrrrrr)rZorthogonal_poly_classesZorthogonal_poly_var_indexrklassZ var_indexrrerrforthogonal_poly_rules,   rc sv|\}}td|gddgd}td|gd}td|gd}td|gd dgd}td |gd dgd}|||||f}tt||||dtftt||||dtftt||||dtftt||||dt ftt ||||dt ft d t |||dtftt||d |||dtftt||d |||dtftt||d |||dtft||t||dtftt||||dtft d t||t|d ddtft t||t|d ddtff } | D]x} t|| dr|| d rtfdd|D} | d dusR| d | r| ||f} | d| SqdS)NrcSs|j Sr^r rrererfrhriz'special_function_rule..rZ propertiesrrcrcSs|j Sr^rrrererfrhriecSs|jo |j Sr^)is_nonnegative is_integerrrererfrhrirMrcSs||kSr^rerrrererfrhricSs||kSr^rerrererfrhrirc3s&|]}|dur|VqdSr^)r)rwrrerfrsz(special_function_rule..r)rr rrr'rrrr(rrrrrrrrrrrLrr#rrrrr`) rrrrrrrrZwildspatternspZ wild_valsrrerrfspecial_function_rulesF""" rc s|\\}tdgd}tdgd}||dsNdSdd}dd}d d }fd d fd d||fD\}}g}td|ddkr |t||d| dt|dk|dkf||||d|dt|dk|dkf|||| d|dt|dk|dkfdd|D}|jrp|jrpdd|D}t|dkr|dddSn |rt fdd|DSdS)NrrrrcSs|jp |Sr^) is_negativeZcould_extract_minus_signrrererfnegativesz#inverse_trig_rule..negativecSs tt||Sr^)r}r rrrererf ArcsinhRulesz&inverse_trig_rule..ArcsinhRulecSs tt||Sr^)r}rr rererf ArccoshRulesz&inverse_trig_rule..ArccoshRulecs td}}}d} } } } } |dkrT||} |||||d}||} ||dkrt||} t||} |}|||d}||||} | dur| dkr| durt| ||| | ||} t|| | | | } | dur| durt| | | } | S)NrrMr)rr#rqru)Z RuleClassZbase_exprZsign_arZsign_brZ current_baseZcurrent_symbolrpu_funcZ u_constantrZfactored)rrrrerfmake_inverse_trigs2    z,inverse_trig_rule..make_inverse_trigcsg|]}|tjqSrerrrrerfrriz%inverse_trig_rule..rMrcSsg|]}|dtjur|qSr%)rfalserrrererfrricSsg|]}|dtjur|qSr&)rtruer(rererfrrics$g|]}|dd|dfqSNr%rer()r$rerfrri) r rrrUrr|rP is_numberrr) rrrrrr!r" possibilitiesZ possibilityre)rrr$rrrfinverse_trig_rules6 (&(r-cs6|\}fdd|D}d|vr*dSt||S)Ncsg|]}t|qSre)r)rgrrerfr szadd_rule..)Zas_ordered_termsrs)rrrrerrfadd_rule s  r/cCsD|\}}||\}}t||}|dkr@|dur@t|||||SdSNrM)rrrq)rrrZcoeffr next_steprererfmul_rules r2csfdd}dd}|t|t||tt|tg}td}t|tgtRrV||}t|D]\}}||}|r^|\} } | jvr| |sdS| |d} | |d} ||kr| sdSt| trd| } | rt | dkrdS||krJt| t rJt| } t| r&dS| } t| }| | || | fSd}|dkr^d }nv||kr| jrtd d | jDrd }nH||ddD]6}||}|r|d  |d| rd }qԐq|r^| } tt| } t| s^t| }| | || | fSq^dS) NcsR|}t|trgnfdd|jD}|rNt|}||}||fSdS)Ncsg|]}|r|qSre)Zis_algebraic_exprrrrerfr#riz;_parts_rule..pull_out_algebraic..)rZtogetherrr%rr )rZ algebraicrdvrrerfpull_out_algebraics  z'_parts_rule..pull_out_algebraiccsfdd}|S)NcsPtfddDrLfddjD}|rLtdd|}|}||fSdS)Nc3s|]}|VqdSr^rrrrrerfr+rizI_parts_rule..pull_out_u..pull_out_u_rl..cs&g|]tfddDrqS)c3s|]}t|VqdSr^)r)rrmrrerfr-rizT_parts_rule..pull_out_u..pull_out_u_rl...)r)r functionsr7rfr,szJ_parts_rule..pull_out_u..pull_out_u_rl..cSs||Sr^re)rrrererfrh/rizH_parts_rule..pull_out_u..pull_out_u_rl..)rrr)rrrr3r8r6rf pull_out_u_rl*s z6_parts_rule..pull_out_u..pull_out_u_rlre)r9r:rer8rf pull_out_u)s z_parts_rule..pull_out_u temporaryrMFrTcss|]}t|tttfVqdSr^)rr(r'rrrrererfresz_parts_rule..r)rrr(r'rrr enumeraterrr is_polynomialrSrJrrr_manualintegraterallequalsrU)rrr4r;Z liate_rulesdummyindexrrrr3Zrec_dvv_stepduracceptZlrulerrerrf _parts_rulesh              rHcs|\}|\}}t|}g}|r|\}}}}} td||||| ||t|trddSt|ttt t t fr| t i} t| dkrdSt| d7<tdD]} td| ||||||} | dkrq| jvr@tdd|Ddt|| |} |dkr8| r8t||| ||} | S||\}}t|}|r|\}}}}} ||9}||9}|||||| fqqqfd d |r|d \}}}}} t||| |dd|||} |dkr | r t||| ||} | SdS) Nz,u : {}, dv : {}, v : {}, du : {}, v_step: {}rrMz7Cyclic integration {} with v: {}, du: {}, integrand: {}c Ss(g|] \}}}}}t|||dddqSr^)rv)rrr3rrFrErererfrs zparts_rule..r%csZ|r:|d\}}}}}t||||dd|||St|}|rL|St|SdS)NrrM)rvrr)stepsrrr3rrFrEmake_second_steprrerfrLs z$parts_rule..make_second_stepr)Z as_coeff_MulrHr\rrrrOr(r'rrrxreplace _cache_dummy_parts_u_cacherangerrrwrrqrv)rrrprrJrr3rrFrEcachekey_ coefficientrZ next_constantZnext_integrandrerKrf parts_rulewsj         rTcCsl|\}}t|ttfrP|jd}t|ts.dSt|tr>d}nd}t||||S|t|dkrntd|||S|t|dkrtd|||St|trt|jt|j}nt|t rt|jt|j}nt|tr|jd}t|dt|t|t|t|}nHt|trT|jd}t|dt |t|t|t |}ndSt |t ||||S)Nrr(r'rsec**2csc**2) rr(r'rrrxr,r+r)r*rr)rrrrr{rrererf trig_rulesB         rWcCs|\}}t|t|}||}||jvrXtd|||}|dkrT|rTt|||||}|St| t|}||}||jvrtd|||}|dkr|rt|||||}|SdS)Nsec*tanrMcsc*cot)r,r)rrxrqr+r*)rrrZsectanqrZcsccotrererftrig_product_rules    r[c Cs|\}}td|gd}td|gd}td|gd}||||d|}|r||||||}}}|jr |jr tt|||||t||dft|||||tt|d| |t||dft |||||tt|d| |t||dfg||St|||||Std|gd}||||d|||}|r||||}}|j rndSt d} ||d|} | || |d|} t | | } | rt| | d| | |SdStd |gd} ||||||d||| }|r|||||||||| f\}}}}} |j r:dS||d||| }|d|}d|||}| ||}t d} t| ||t | d | ||}|d krt||||||||}|j r|St |||}t||g||}|||||}t||||SdS) Nrrrrrrrrrr%rM)rris_extended_realrrrrrPrrr rrrrurqrsr)rrrrrrrrZmatch2rr#Z integrand2r1rZmatch3 denominatorconstZnumer1Znumer2Zstep1Zstep2rtZrewritenrererfquadratic_denom_rulesx22" *,    r_cCs"|\}}td|gd}td|gd}td}|t||||}|sNdS||||||}}}td|gd}td|gd}td} |t|||| } | rdStd} t|||} || | }||| d ||}|d | |}t|| } | rt| | d| ||SdS) Nrrrrrrrrr)rrr#rrrru)rrrrrrrrrrZrecursion_testrr#r1rererf root_mul_ruleCs,  r`cCsTtd|gd}td|gd}td|gddgd}td|gd dgd}||||fS) NrrrmcSs t|tSr^rrrrererfrhbrizmake_wilds..rrcSs t|tSr^rbrcrererfrhcri)r)rrrrarrererf make_wilds^s rdcCs>t|\}}}}t|||t|||}|||||fSr^)rdr(r'rrrrarpatternrererfsincos_patterngs rgcCs>t|\}}}}t|||t|||}|||||fSr^)rdr)r,rerererftansec_patternns rhcCs>t|\}}}}t|||t|||}|||||fSr^)rdr*r+rerererfcotcsc_patternus ricCsDtd|gd}td|gd}td}t||||}||||fS)Nrarrr.)rr3)rrarr.rfrererfheaviside_pattern|s rjcsfdd}|S)Ncs|Sr^rerrrerf uncurry_rlszuncurry..uncurry_rlre)r{rlrerrfuncurrys rmcsfdd}|S)NcsB|\}}}}}}||||||}||kr>t|t||||SdSr^)rr)rrrrarrrrrrerftrig_rewriter_rlsz'trig_rewriter..trig_rewriter_rlre)rrorernrf trig_rewriters rpcCs|jo|jo|jo|jSr^)is_evenrrrrarrsrererfrhs rhcCs@dtd||d|ddtd||d|dSNrMr)r'rrrarrrrererfrhscCs|jo |dkSNrZis_oddrrrererfrhricCs<dt||d|ddt||t|||Srt)r'r(rurererfrhs cCs|jo |dkSrvrwrrrererfrhricCs<dt||d|ddt||t|||Srt)r(r'rurererfrhs cCs|jo |dkSNrIrqrrrererfrhricCs@dt||d|ddt||dt|||Srt)r)r,rurererfrhscCs|jSr^rwrrrererfrhricCs<t||dd|ddt||t|||SNrrM)r,r)rurererfrhs cCs|dko|dkS)NrrrerrrererfrhricCst||ddSrz)r,rurererfrhricCs|jo |dkSrxryrrrererfrhricCs@dt||d|ddt||dt|||Srt)r*r+rurererfrhscCs|jSr^rwrrrererfrhricCs<t||dd|ddt||t|||Srz)r+r*rurererfrhs cs|\}tfddttfDrt|\}}}}}|sFdSttttt t t it fdd||||fD|gSdS)Nc3s|]}|VqdSr^rr5r6rerfrriz#trig_sincos_rule..csg|]}|tjqSrerrrrerfrriz$trig_sincos_rule..) rr(r'rgrrsincos_botheven_conditionsincos_bothevensincos_sinodd_condition sincos_sinoddsincos_cosodd_condition sincos_cosoddr`rrrfrrrarrerrrftrig_sincos_rules" rcs|\}dt|t|itfddttfDrt|\}}}}}|s`dSttt t t t t itfdd||||fD|gSdS)NrMc3s|]}|VqdSr^rr5r6rerfrriz#trig_tansec_rule..csg|]}|tjqSrerrrrerfrriz$trig_tansec_rule..)rr'r,rr)rhrrtansec_tanodd_condition tansec_tanoddtansec_seceven_conditiontansec_seceventan_tansquared_conditiontan_tansquaredr`rrerrftrig_tansec_rules( rc s|\}dt|t|dt|t|t|t|t|itfddttfDrt|\}}}}}|sdSt t t t t itfdd||||fD|gSdS)NrMc3s|]}|VqdSr^rr5r6rerfrriz#trig_cotcsc_rule..csg|]}|tjqSrerrrrerfrriz$trig_cotcsc_rule..)rr(r+r)r*r'rrirrcotcsc_cotodd_condition cotcsc_cotoddcotcsc_csceven_conditioncotcsc_cscevenr`rrerrftrig_cotcsc_rules* rcCsj|\}}tdtd|gd}|td||}|rfdt|t|td|}t|||SdS)Nrrr)rr(rr'r)rrrrrZ sin_doublerererftrig_sindouble_rules  rcCs"ttttttttt|Sr^)rXrYrrrrrrererftrig_powers_products_rule src Csb|\}}tdd|gd}tdd|gd}td}|||d}||}|D] }||} | |tj} | |tj} | jr| dkp| j} | jr| dkp| j} | jr| dkp| j }| jr| dkp| j }d}| r| rt | t | t |}d}n~| r4|r4t | t | }|t |}t || k||k}n>|rr| rrt | t | }|t|}t || k||k}|rNi}t tt tttfD]:}|||t ||d<d|||t ||d <q|||}t||}||sN|t||9}|}|dt|}|r2|dt|t|i}t||}t|sNt|||||||SqNdS) NrrrrthetarTrM)rrfindrrrrr+Z is_positiverr#r)r(rPr,r'r+r*rtrigsimprrrrMrrr)rrrABrZtarget_patternmatchesrrrrZ a_positiveZ b_positiveZ a_negativeZ b_negativeZx_func restrictionrp substitutionsrZreplacedZsecantsrrererftrig_substitution_rulesb            rc Cs||\}}t|\}}}}||}|rxd||krxt|||}t|} ||||}}t|||| || ||SdSr )rjrrr@r) rrrrfrarr.rrErrererfheaviside_ruleMs rc Cs|\}}td}t|||}d}|rhtdg}|D]\}}} t| |} |d}td|| t| rnq6t|ddkr$|\} } | rt|| | | |} | j r$g} g}t | t r| j }n | | |D]8}t|jstt||d|}|r| |t|dfq| | dft| | |} | t|||| ||q6t|dkrXt|||S|r|dSnV|trt|}d}|||} | ||} || j vrt|||t| |||SdS)NrrzList of Substitution RulesrMrT)rrr\rrrrUrrqrrr rrr r rrrrurr~rrrr)rrrrrrZwaysr#rrZsubrulerRdenomZ piecewiseZ could_be_zerorrrererfsubstitution_ruleXsf             rcCs|Sr^)rr rererfrhricCs ||Sr^)Zapartr rererfrhricCsdS)NTrer rererfrhricCs|Sr^)rr rererfrhrics,tfdd|jDp*t|tp*t|tS)Nc3s|]}|jp|VqdSr^)rr?rrrerfrriz..)rArrrr r rerrfrhscCs|Sr^expandr rererfrhricCstdd|tDdkS)NcSsh|]}|jdqS)rrkr=rererf riz..rM)rZatomsr&r rererfrhscCs |jddS)NT)Ztrigrr rererfrhricCsZ|d}|j}|j}|j}|j|vrD|j|vr6t|St||jSnt|jg|RSdSr ) variablesrrrrrror)rrZdiff_variablesZundifferentiated_functionZintegrand_variablesrererfderivative_rules  rcCsJ|\}}|dt|rF|dt|t|}t|t||||SdSr0)rr'rr,rr)rrrrrererf rewrites_rulesrcCst|Sr^)rrrererf fallback_rulesrzc sP|ti}|tvrBt|dur,t|St|tfSndt|<t|}fddfdd}tttttt ttt tt tt t t tttttttttttttt tttttttttttti ttttt t!t"t#|tt t$t#|tt t%t#|tt&gt'Rt(t#|tt t)t*t+tt,t-|}t|=|S)aReturns the steps needed to compute an integral. Explanation =========== This function attempts to mirror what a student would do by hand as closely as possible. SymPy Gamma uses this to provide a step-by-step explanation of an integral. The code it uses to format the results of this function can be found at https://github.com/sympy/sympy_gamma/blob/master/app/logic/intsteps.py. Examples ======== >>> from sympy import exp, sin >>> from sympy.integrals.manualintegrate import integral_steps >>> from sympy.abc import x >>> print(repr(integral_steps(exp(x) / (1 + exp(2 * x)), x))) # doctest: +NORMALIZE_WHITESPACE URule(u_var=_u, u_func=exp(x), constant=1, substep=PiecewiseRule(subfunctions=[(ArctanRule(a=1, b=1, c=1, context=1/(_u**2 + 1), symbol=_u), True), (ArccothRule(a=1, b=1, c=1, context=1/(_u**2 + 1), symbol=_u), False), (ArctanhRule(a=1, b=1, c=1, context=1/(_u**2 + 1), symbol=_u), False)], context=1/(_u**2 + 1), symbol=_u), context=exp(x)/(exp(2*x) + 1), symbol=x) >>> print(repr(integral_steps(sin(x), x))) # doctest: +NORMALIZE_WHITESPACE TrigRule(func='sin', arg=x, context=sin(x), symbol=x) >>> print(repr(integral_steps((x**2 + 3)**2, x))) # doctest: +NORMALIZE_WHITESPACE RewriteRule(rewritten=x**4 + 6*x**2 + 9, substep=AddRule(substeps=[PowerRule(base=x, exp=4, context=x**4, symbol=x), ConstantTimesRule(constant=6, other=x**2, substep=PowerRule(base=x, exp=2, context=x**2, symbol=x), context=6*x**2, symbol=x), ConstantRule(constant=9, context=9, symbol=x)], context=x**4 + 6*x**2 + 9, symbol=x), context=(x**2 + 3)**2, symbol=x) Returns ======= rule : namedtuple The first step; most rules have substeps that must also be considered. These substeps can be evaluated using ``manualintegrate`` to obtain a result. Ncsj|j}|jvrtSt|tr"tSt|tr0tStttt t t gt t tRD]}t||rN|SqNdSr^)rrrrr&r rrrrrr rr3rJ)rrrmrrerfrs$     zintegral_steps..keycsfdd}|S)Ncs|}|ot|Sr^) issubclass)rk)rklassesrerf_integral_is_subclass szKintegral_steps..integral_is_subclass.._integral_is_subclassre)rr)r)rrfintegral_is_subclasssz,integral_steps..integral_is_subclass).rMrN_integral_cacherrrXrYrrWrr r-r_rrr rr/r r2r[rr`r rr&rWr3rJrrrrrrrZpartial_fractions_rule cancel_rulerrrTdistribute_expand_rulertrig_expand_rulerr)rroptionsrQrrrre)rrrfrs2      ()rcCs||Sr^re)rprrrererf eval_constantQsrcCs |t|Sr^r@)rprdrrrrererfeval_constanttimesUsrcCs,t||d|dt|dft|dfSNrMr%T)r%rrrrrrrererf eval_powerYs rcCs |t|Sr^rrrererfeval_exp`srcCsttt|Sr^)rmapr@rtrrrererfeval_adddsrcCs<t|}|jr0|jdkr0|t|t|j }|||Sr*)r@rrrrr)rr#rprrrrrererfeval_uhsrcCst|}||t|Sr^r)rr3rEZ second_steprrrrererf eval_partspsrcCsHd|}g}d}|D]&}|||jt|j|d9}qt||S)NrMr%)rrr@rEr)Z parts_rulesrSrrrsignrrererfeval_cyclicpartsvs rcCsh|dkrt| S|dkr"t|S|dkr2t|S|dkrBt|S|dkrRt|S|dkrdt| SdS)Nr(r'rXrYrUrV)r'r(r,r+r)r*)r{rrrrererf eval_trigs rcCs,||dt||t|t||Sr0)r#r/rrrrrrererf eval_arctansrcCs2| |dt| |t|t| |Sr0)r#r!rrererf eval_arccothsrcCs2| |dt| |t|t| |Sr0)r#r"rrererf eval_arctanhsrcCst|Sr^rr{rrrererfeval_reciprocalsrcCst|Sr^)r.r rererf eval_arcsinsrcCs||Sr^rerrererfeval_inversehyperbolicsrcCs t|dSr r)rrrrererfeval_alternativesrcCst|Sr^r)rrrrrererf eval_rewritesrcCstdd|DS)NcSsg|]\}}t||fqSrer)rrcondrererfrsz"eval_piecewise..r$rrererfeval_piecewisesrcCs|t|dt|}|t|dt|}|t|dt|}t|t }t |dksfJ|d}t |||}t |dksJt |d\} } t |tr| } | } t| d| d} t|d}njt |tr| } | } t| d| d} t|d}n4t |tr:| } | } t| d| d} t|d}t|| | ft|| | ft|| | f||fg}tt|||fS)NrMrr)rr,r'r+r(r*r)rrr&rrVrTrr#r.r-r/r%r@r)rr{rrrrrZ trig_functionZrelationZnumerroppositeZ hypotenuseadjacentZinverserrererfeval_trigsubstitutions@    rcCsNt|j}t|D](\}\}}||kr||df||<qr r)rrrrvarrrererfeval_derivativerules  rcCst|||||Sr^)r3r)ZhargZibndrrrrererfeval_heavisidesrcCs|tdt|d|d|d||||t|||df|t|df||d|dd|||dt|dfS)NrrMrrI)r%rIrr)rrrrrrererf eval_jacobis : 0rcCsTtt|d|d|d|dt|dft|d||dt|dftjdfS)NrMrr%T)r%rHrrBrrrrrrrererfeval_gegenbauers (rcCsPtt|d||dt|d||ddtt|df|dddfS)NrMrT)r%rBrrrrrrererfeval_chebyshevts rcCs,tt|d||dt|dftjdfSr)r%rBrrrrrererfeval_chebyshevusrcCs(t|d|t|d|d|dSrt)rDrrererf eval_legendre srcCst|d|d|dSrt)rErrererf eval_hermite srcCst||t|d|Sr0)rFrrererf eval_laguerresrcCst|d|d| Sr0)rGrrererfeval_assoclaguerresrcCs(t|t||t|t||Sr^)r'r8r(r:rrrrrererfeval_cisrcCs(t|t||t|t||Sr^)rr9rr;rrererfeval_chisrcCst|t||Sr^)rr<rrererfeval_ei!srcCs(t|t||t|t||Sr^)r(r8r'r:rrererfeval_si%srcCs(t|t||t|t||Sr^)rr9rr;rrererfeval_shi)srcCs|jrtttj| dt||dd|td|||dt| |dkfttj|dt||dd|td|||dt|dfSttj|dt||dd|td|||dt|SdS)NrrIrrT)r\r%r#rPirr4r5rrererfeval_erf-s * ((rcCsttjd|t|dd||td|||td|tjt|dd||td|||td|tjSNrrI)r#rrr'r6r(r7rrererf eval_fresnelc9s <<rcCsttjd|t|dd||td|||td|tjt|dd||td|||td|tjSr)r#rrr'r7r(r6rrererf eval_fresnels?s <<rcCst||||Sr^)r=rrererfeval_liEsrcCst|d||Sr0rKrrererf eval_polylogIsrcCs0||| || t|d| ||Sr0r>)rrrrrererfeval_uppergammaMsrcCst|||t|Sr^)rAr#rrrrrererfeval_elliptic_fQsrcCst|||t|Sr^)r@r#rrererfeval_elliptic_eUsrcCs t||Sr^rNr rererfeval_dontknowruleYsrcCs(t|j}|s tdt|||S)NzCannot evaluate rule %s)rrr_rrepr)rZ evaluatorrererfr@]s r@cCstt||}tt|trt|jdkr|jdd}t|tr|jdddkr| |jddt |jf|jdddf}|S)a$manualintegrate(f, var) Explanation =========== Compute indefinite integral of a single variable using an algorithm that resembles what a student would do by hand. Unlike :func:`~.integrate`, var can only be a single symbol. Examples ======== >>> from sympy import sin, cos, tan, exp, log, integrate >>> from sympy.integrals.manualintegrate import manualintegrate >>> from sympy.abc import x >>> manualintegrate(1 / x, x) log(x) >>> integrate(1/x) log(x) >>> manualintegrate(log(x), x) x*log(x) - x >>> integrate(log(x)) x*log(x) - x >>> manualintegrate(exp(x) / (1 + exp(2 * x)), x) atan(exp(x)) >>> integrate(exp(x) / (1 + exp(2 * x))) RootSum(4*_z**2 + 1, Lambda(_i, _i*log(2*_i + exp(x)))) >>> manualintegrate(cos(x)**4 * sin(x), x) -cos(x)**5/5 >>> integrate(cos(x)**4 * sin(x), x) -cos(x)**5/5 >>> manualintegrate(cos(x)**4 * sin(x)**3, x) cos(x)**7/7 - cos(x)**5/5 >>> integrate(cos(x)**4 * sin(x)**3, x) cos(x)**7/7 - cos(x)**5/5 >>> manualintegrate(tan(x), x) -log(cos(x)) >>> integrate(tan(x), x) -log(cos(x)) See Also ======== sympy.integrals.integrals.integrate sympy.integrals.integrals.Integral.doit sympy.integrals.integrals.Integral rrrMT) r@rrOclearrr%rrrr{r)rrrrrererfmanualintegrateds1rN)r](__doc__typingrZtDictr collectionsrrcollections.abcr functoolsrZsympy.core.addrZsympy.core.cacher Zsympy.core.containersZsympy.core.exprr Zsympy.core.functionr Zsympy.core.logicr Zsympy.core.mulr Zsympy.core.numbersrrrZsympy.core.powerrZsympy.core.relationalrrrrZsympy.core.singletonrZsympy.core.symbolrrrZ$sympy.functions.elementary.complexesrZ&sympy.functions.elementary.exponentialrrZ%sympy.functions.elementary.hyperbolicrrrr r!r"Z(sympy.functions.elementary.miscellaneousr#Z$sympy.functions.elementary.piecewiser%Z(sympy.functions.elementary.trigonometricr&r'r(r)r*r+r,r-r.r/r0r1r2Z'sympy.functions.special.delta_functionsr3Z'sympy.functions.special.error_functionsr4r5r6r7r8r9r:r;r<r=Z'sympy.functions.special.gamma_functionsr?Z*sympy.functions.special.elliptic_integralsr@rAZ#sympy.functions.special.polynomialsrBrCrDrErFrGrHrIrJZ&sympy.functions.special.zeta_functionsrLZ integralsrOZsympy.logic.boolalgrPZsympy.ntheory.factor_rQZsympy.polys.polytoolsrSZsympy.simplify.radsimprTZsympy.simplify.simplifyrUZsympy.solvers.solversrVZsympy.strategies.corerWrXrYrZZsympy.utilities.iterablesr[Zsympy.utilities.miscr\rnrorqrrrsrurvrwrxryrzr|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrr-r/r2rHrTrWr[r_r`rdrgrhrirjrmrpr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrintrOrNrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr@rrerererfs(               < 0 ,                                                   ![(A [L)@             = ?                  &