B [@s<dZddlmZmZddlmZddlZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZmZmZmZdd lmZmZdd lmZejjZdddZeddZeddZ eddZ!eddZ"eddZ#eddZ$eddZ%eddZ&ed dZ'ed!d"Z(ed#Z)ed$d"Z*ed%d&Z+ed'Z,ed(Z-ed)d*Z.ed+d,Z/ed-d.Z0ed/d0Z1ed1d2Z2ed3d2Z3ed4d2Z4ed5d6Z5ed7d8Z6ed9d:Z7ed;d:Z8edd:Z;ed?d8ZdBdCZ?dDdEZ@dFdGZAdHdIZBdJdKZCdLdMZDdNdOZEdPd&ZFdQdRZGdSdTZHdUdVZIdWdXZJdYdZZKd[d\ZLd]d^ZMd_d`ZNdadbZOdcddZPdedfZQdgdhZRdidjZSejTdkdlZUejTdmdnZVejTdodpZWejTdqdrZXejTdsdtZYdudvZZdwdxZ[eZdydzZ\e[d{dzZ]eZd|dzZ^e[d}dzZ_eZd~dzZ`e[ddzZaeZddzZbe[ddzZceZddzZde[ddzZeeZddzZfe[ddzZgeZddzZhe[ddzZieZddzZje[ddzZkddZlddZmddZnddZoddZpddZqddZrddZseCddzddzZteCddzddzZueCddzddzZveCddzddzZwddZxddZyddZziZ{ddZ|e?eddZ}e?e ddZ~e?e!ddZe?e'ddZe?e"ddZe?e#ddZe?e$ddZe?e%ddZe?e&ddZe?e2ddZe?e3ddZe?e4ddZe?e(ddÄZe?e)ddńZe?e*ddDŽZe?e+ddɄZe?e.dd˄Ze?e/dd̈́Ze?e1ddτZe?e-ddфZe?e0ddӄZe?e5ddՄZe?e6ddׄZe?e7ddلZe?e8ddۄZe?e9dd݄Ze?e:dd߄Ze?e;ddZe?e<ddZe?e,ddZddZddZdS)aIntegration 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. )print_functiondivision) namedtupleN)reduce) fuzzy_not)TrigonometricFunction)OrthogonalPolynomial) Piecewise)switchdo_one null_safe condition)EqNe)degreecs2ddfdd}t||d}|_||_|S)NcSs|j|jkot||S)N) __class__tuple__eq__)selfotherr>lib/python3.7/site-packages/sympy/integrals/manualintegrate.pyr&szRule..__eq__cs || S)Nr)rr)rrr(szRule..z context symbol)rr__ne__)nameZpropsZ__neq__clsr)rrRule$s  r 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 LaguerreRuleAssocLaguerreRule IntegralInfozintegrand symbolcsfdd}|S)Ncs|_|t<|S)N)rule evaluators)r*)rBrr _evaluatesRszevaluates.._evaluatesr)rBrDr)rBr evaluatesQs rEcCsXt|trdSxD|D]<}t|tr0t|rPdSqt|trtdd|DrdSqWdS)NTcss|]}t|VqdS)N)contains_dont_know).0irrr asz%contains_dont_know..F) isinstancer/rrFlistany)rBvalrrrrFXs    rFcs,|jr"|jd}t|tjr6|t|dSt|tjr\| t|dSt|tjr|t|t|St|tjr| t|t|St|tjrt fdd|jDSt|tj r"t |jdkr"t|jdtj 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|qSr) manual_diff)rGarg)symbolrr xszmanual_diff..)argsrJsympytandiffseccotcscAddsumMullenNumberrO)frQrPr)rQrrOes        $rOc sg}fdd}fddxlD]`}|kr:q,t|}|||}|dk r,|\}}|krpq,|||f} | |kr,|| q,W|S)Ncs|}|jkrdS||}|jkr>|jddSt|tjrd|jjrt |jdkrtj dgd}tj dgd}|j ||rfdd||fD\}}|d kr|d kr|d|j||}|jddSdS) NF)Zas_AddrSa)excludebcsg|]}|tqSr)getZERO)rGrH)matchrrrRsz.test_subterm..r) free_symbolssubscancelas_independentrJrUPowexpZ is_IntegerAbsWildbaserf)uu_diff substitutedrarc) integrandrQu_var)rfr test_subterms$  z(find_substitutions..test_subtermc s\t|ttjtjtjtjtjtjfr0|j dgSt|tj tj tj tj tjfrZ|j dgSt|tjtjfrx|j dgSt|tjr|j dgSt|tjrg}x&|j D]}||||qW|St|tjr|j dr|j dgS|j drX|j dgSn@t|tjrXg}x(|j D]}||||q2W|SgS)NrrSrN)rJrrUasinacosatanrllog HeavisiderT chebyshevt chebyshevulegendrehermitelaguerre gegenbauerassoc_laguerrejacobir]appendextendrkZ is_constantr[)ZtermrrprP)possible_subtermsrQrrrs:             z-find_substitutions..possible_subtermsF)rOrhr) rsrQrtresultsrurprqZ new_integrandr substitutionr)rsrrQrtrfind_substitutionss    rcsfdd}|S)z$Strategy that rewrites an integrand.csJ|\}}|rF|}||krFt||}t|tsF|rFt||||SdS)N)integral_stepsrJr/r1)integralrsrQ rewrittensubstep)r rewriterr _rewriters zrewriter.._rewriterr)r rrr)r rrrewriters rcsfdd}|S)zAStrategy that rewrites an integrand based on some other criteria.csL|\}}|\}}|t|}|rH|}||krHt|t||||SdS)N)rKr1r)ZcriteriarrsrQrTr)r rrr_proxy_rewriters z'proxy_rewriter.._proxy_rewriterr)r rrr)r rrproxy_rewriters rcsfdd}|S)z4Apply the rule that matches the condition, else Nonecs*x$D]\}}||r ||Sq WdS)N)items)exprkeyrB) conditionsrrmultiplexer_rlsz#multiplexer..multiplexer_rlr)rrr)rr multiplexers rcsfdd}|S)zHStrategy that makes an AlternativeRule out of multiple possible results.csg}x<D]4}||}|r t|ts ||kr ||kr ||q Wt|dkrV|dS|rdd|D}|rzt|f|St|f|SdS)NrSrcSsg|]}t|s|qSr)rF)rGrBrrrrRsz7alternatives.._alternatives..)rJr/rr^r-)rZaltsrBresultZdoable)rulesrr _alternativess  z#alternatives.._alternativesr)rrr)rrr.s cCs|\}}t|jf|S)N)rrs)rrsrQrrr constant_rulesrcCs|\}}|\}}||jkrVt|tjrVt|ddkrHt|||St||||S||jkrt|tjrt||||}t t |j r|St |j rt dd|St |tt |dft dd|dfg||SdS)NrSrT) as_base_exprgrJrUSymbolsimplifyr)r!r(rrzis_zerorr2r)rrsrQrorlrBrrr power_rules     rcCs4|\}}t|jdtjr0ttj|jd||SdS)Nr)rJrTrUrr(E)rrsrQrrrexp_rulesrcstjttjttjttjttj t tj t tj ttjti}tjdtjdtjdi}|\}xr|D]j}t||rX||d}|j|krXtfdd|jd|DsX|jd||f}|||SqXWdS)NrvrNrSc3s|]}|VqdS)N)has)rGv)rQrrrI8sz'orthogonal_poly_rule..)rUrr8rr9r|r:r}r<r~r=rr>rr?rr@rJrdrTrL)rZorthogonal_poly_classesZorthogonal_poly_var_indexrsklassZ var_indexrTr)rQrorthogonal_poly_rule#s&      rc s|\\}tjdgd}tjdgd}||dsRdSdd}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}|jr||jr|dd|D}t |dkr|dddSn |rt fdd|DSdS)Nra)rbrcrNcSs|jp |S)N) is_negativeZcould_extract_minus_sign)xrrrnegativeGsz#inverse_trig_rule..negativecSsttj||S)N)r,rUZasinh)rsrQrrr ArcsinhRuleJsz&inverse_trig_rule..ArcsinhRulecSsttj||S)N)r,rUZacosh)rsrQrrr ArccoshRuleMsz&inverse_trig_rule..ArccoshRulecstd}}}d} } } } } |dkrV||} |||||d}||} ||dkrt||} t||} |}|||d}||||} | dk r| dkr| dk rt| ||| | ||} t|| | | | } | dk r| dk rt| | | } | S)NrprSrN)rUDummysqrtr r$)Z RuleClassZbase_expraZsign_arcZsign_brtZ current_baseZcurrent_symbolru_funcZ u_constantrZfactored)rorsrQrrmake_inverse_trigPs0   z,inverse_trig_rule..make_inverse_trigcsg|]}|tqSr)rdre)rGrH)rfrrrRksz%inverse_trig_rule..rSrcSsg|]}|dtjk r|qS)r)rUZfalse)rGprrrrRtscSsg|]}|dtjkr|qS)r)rUtrue)rGrrrrrRvscs$g|]}|dd|dfqS)Nrr)rGr)rrrrR{s) rrUrnrfrrr+And is_numberr^r2) rrlrarcrrrZ possibilitiesZ possibilityr)rorsrrfrQrinverse_trig_rule=s4 *(*rcs6|\}fdd|D}d|kr*dSt||S)Ncsg|]}t|qSr)r)rGg)rQrrrRszadd_rule..)Zas_ordered_termsr")rrsrr)rQradd_rule~s  rcCsJ|\}}|j}||\}}t||}|dkrF|dk rFt|||||SdS)NrS)rTrjrr )rrsrQrTZcoeffr` next_steprrrmul_rules rcsfdd}dd}|tj|tjtjtj||tjtj|tjg}td}t |tjtjtjtjfrr||}xht |D]Z\}}||}|r~|\} } | j kr| |sdS| |d} | |d} ||kr| sdSt | tjrd| } | rt| dkrdS||krht | trht| } t | trHdS| } t| }| | || | fSxp||ddD]\}||}|rz|d |d| rz| } tt| } t| }| | || | fSqzWq~WdS)NcsF|}fdd|jD}|rBtj|}||}||fSdS)Ncsg|]}|r|qSr)Zis_algebraic_expr)rGrP)rQrrrRsz;_parts_rule..pull_out_algebraic..)riZtogetherrTrUr])rsZ algebraicrpdv)rQrrpull_out_algebraics    z'_parts_rule..pull_out_algebraiccsfdd}|S)NcsPtfddDrLfddjD}|rLtdd|}|}||fSdS)Ncsg|]}|qSr)r)rGr`)rsrrrRszJ_parts_rule..pull_out_u..pull_out_u_rl..cs&g|]tfddDrqS)c3s|]}t|VqdS)N)rJ)rGr)rPrrrIszT_parts_rule..pull_out_u..pull_out_u_rl...)rL)rG) functions)rPrrRscSs||S)Nr)rarcrrrrszH_parts_rule..pull_out_u..pull_out_u_rl..)rLrTr)rsrTrpr)r)rsr pull_out_u_rls z6_parts_rule..pull_out_u..pull_out_u_rlr)rrr)rr pull_out_us z_parts_rule..pull_out_uZ temporaryrSr)rUrzryrwrxsincosrlrrJ enumeratergrrh is_polynomialrrrr/rW_manualintegrateZequalsr)rsrQrrZ liate_rulesZdummyindexrBrrprZrec_dvv_stepdurrr)rQr _parts_rulesJ           rc s|\}|\}}t|}g}|r |\}}}}} ||t|tjrPdSx|||dkrhP|||jkr|||} tdd|Ddt || |} |dkr| rt ||| ||} | St||}|r|\}}}}} ||qRPqRWfdd|r||d\}}}}} t ||| |dd|||} |dkrx| rxt ||| ||} | SdS)NrSc Ss(g|] \}}}}}t|||dddqS)N)r%)rGrprrrrrrrrRszparts_rule..rcsZ|r:|d\}}}}}t||||dd|||St|}|rL|St|SdS)NrrS)r%rr/)stepsrsrprrrr)make_second_steprQrrrs z$parts_rule..make_second_stepr) Z as_coeff_MulrrrJrUIntegralrirgr&r^r r%) rrsrrrrprrrr coefficientrBr)rrQr parts_rulesL         rcCs|\}}t|tjs t|tjr^|jd}t|tjs:dSt|tjrLd}nd}t||||S|t|dkr~td|||S|t|dkrtd|||St|tj rtj|jtj|j}nt|tj rtj|jtj|j}nt|tjr:|jd}t|dt |t|t|t |}nTt|tjr|jd}t|dt |t|t|t |}ndSt |t ||||S)NrrrrNzsec**2zcsc**2) rJrUrrrTrr'rXrZrVrYr1r)rrsrQrPr*rrrr trig_rules<         rcCs|\}}t|t|}||}||jkr\td|||}|dkrX|rXt|||||}|St| t|}||}||jkrtd|||}|dkr|rt|||||}|SdS)Nzsec*tanrSzcsc*cot)rUrXrVrgr'r rZrY)rrsrQZsectanqrBZcsccotrrrtrig_product_ruleEs    rc Cs|\}}tjd|gd}tjd|gd}tjd|gd}||||d|}|sZdS||||||}}}tt|||||t||dft|||||tt|d| |t||dft |||||tt|d| |t||dfg||S)Nra)rbrccrNr) rUrnrfr2r5ZGtr6rZLtr7)rrsrQrarcrrfrrrquadratic_denom_rule\s 8:rcCs6|\}}tjd|gd}tjd|gd}td}|t||||}|sVdS||||||}}}tjd|gd}tjd|gd}td} |t|||| } | rdStd} t|||} || | }||| d ||}|d | |}t|| } | r2t| | d| ||SdS) Nra)rbrcrder`rprN)rUrnrfrrrhrr$)rrsrQrarcrrfrrr`Zrecursion_testrprrrrr root_mul_rulels,     rcCs\tjd|gd}tjd|gd}tjd|gddgd}tjd|gd dgd}||||fS) Nra)rbrcmcSs t|tjS)N)rJrUInteger)r;rrrrszmake_wilds..)rbZ propertiesr;cSs t|tjS)N)rJrUr)r;rrrrs)rUrn)rQrarcrr;rrr make_wildss rcCsBt|\}}}}t|||t|||}|||||fS)N)rrUrr)rQrarcrr;patternrrrsincos_patterns$rcCsBt|\}}}}t|||t|||}|||||fS)N)rrUrVrX)rQrarcrr;rrrrtansec_patterns$rcCsBt|\}}}}t|||t|||}|||||fS)N)rrUrYrZ)rQrarcrr;rrrrcotcsc_patterns$rcCsLtjd|gd}tjd|gd}td}t||||}||||fS)Nr)rbrcr)rUrnr{)rQrrcrrrrrheaviside_patterns  rcsfdd}|S)Ncs|S)Nr)rT)r*rr uncurry_rlszuncurry..uncurry_rlr)r*rr)r*runcurrys rcsfdd}|S)NcsB|\}}}}}}||||||}||kr>t|t||||SdS)N)r1r)rTrarcrr;rsrQr)rrrtrig_rewriter_rlsz'trig_rewriter..trig_rewriter_rlr)rrr)rr trig_rewriters rcCs|jo|jo|jo|jS)N)is_evenZis_nonnegative)rarcrr;rHsrrrrs rcCsDdtd||d|ddtd||d|dS)NrSrN)rUr)rarcrr;rHrQrrrrs cCs|jo |dkS)Nrv)is_odd)rarcrr;rHrrrrrscCsBdt||d|ddt||t|||S)NrSrN)rUrr)rarcrr;rHrQrrrrs.cCs|jo |dkS)Nrv)r)rarcrr;rHrrrrrscCsBdt||d|ddt||t|||S)NrSrN)rUrr)rarcrr;rHrQrrrrs.cCs|jo |dkS)N)r)rarcrr;rHrrrrrscCsFdt||d|ddt||dt|||S)NrSrN)rUrVrX)rarcrr;rHrQrrrrs2cCs|jS)N)r)rarcrr;rHrrrrrscCsBt||dd|ddt||t|||S)NrNrS)rUrXrV)rarcrr;rHrQrrrrs.cCs|dko|dkS)NrNrr)rarcrr;rHrrrrrscCst||ddS)NrNrS)rUrX)rarcrr;rHrQrrrrscCs|jo |dkS)Nr)r)rarcrr;rHrrrrrscCsFdt||d|ddt||dt|||S)NrSrN)rUrYrZ)rarcrr;rHrQrrrrs2cCs|jS)N)r)rarcrr;rHrrrrrscCsBt||dd|ddt||t|||S)NrNrS)rUrZrY)rarcrr;rHrQrrrrs.cs|\}tfddtjtjfDrt|\}}}}}|sJdStttt t t t it fdd||||fD|gSdS)Nc3s|]}|VqdS)N)r)rGr`)rsrrrIsz#trig_sincos_rule..csg|]}|tqSr)rdre)rGrH)rfrrrRsz$trig_sincos_rule..)rLrUrrrrfrsincos_botheven_conditionsincos_bothevensincos_sinodd_condition sincos_sinoddsincos_cosodd_condition sincos_cosoddr)rrQrrarcrr;r)rsrfrtrig_sincos_rules rcs|\}dt|t|itfddtjtjfDrt|\}}}}}|shdStt t t t t titfdd||||fD|gSdS)NrSc3s|]}|VqdS)N)r)rGr`)rsrrrIsz#trig_tansec_rule..csg|]}|tqSr)rdre)rGrH)rfrrrRsz$trig_tansec_rule..)rhrUrrXrLrVrrfrtansec_tanodd_condition tansec_tanoddtansec_seceven_conditiontansec_seceventan_tansquared_conditiontan_tansquaredr)rrQrrarcrr;r)rsrfrtrig_tansec_rules rc s|\}dt|t|dt|t|t|t|t|itfddtjtjfDrt|\}}}}} |sdSt t t t titfdd||||fD|gSdS)NrSc3s|]}|VqdS)N)r)rGr`)rsrrrIsz#trig_cotcsc_rule..csg|]}|tqSr)rdre)rGrH)rfrrrR(sz$trig_cotcsc_rule..)rhrUrrZrVrYrrLrrfrcotcsc_cotodd_condition cotcsc_cotoddcotcsc_csceven_conditioncotcsc_cscevenr)rrQrrarcrr;r)rsrfrtrig_cotcsc_rules   rcCsv|\}}tjdtd|gd}|td||}|rrdt|t|td|}t|||SdS)NrarN)rb)rUrnrrfrr)rrsrQrarfZ sin_doublerrrtrig_sindouble_rule+s &rcCs"ttttttttt|S)N)r r rrrr)rrrrtrig_powers_products_rule3src Cs|\}}tjdd|gd}tjdd|gd}td}|||d}||}xB|D]8}||} | |t} | |t} | jr| dkp| j} | jr| dkp| j} | jr| dkp| j }| jr| dkp| j }d}| r| rt | t | t |}d}n| rL|rLt | t | }|t |}t || k||k}nF|r| rt | t | }|t|}t || k||k}|rXi}x^tj tjtj tjtjtjgD]>}|||t ||d<d|||t ||d <qW|||}||}||sX|t||9}|}|dt|}|rl|dt|t|i}t||}t|sXt|||||||SqXWdS) Nrar)rbrcthetarNTrS)rUrnrfindrfrdrerZ is_positiverrrVrrrXrrZrYrhtrigsimprrOZxreplacerrFr4)rrsrQABrZtarget_patternZmatchesrrfrarcZ a_positiveZ b_positiveZ a_negativeZ b_negativeZx_func restrictionr substitutionsr`ZreplacedZsecantsrrrrtrig_substitution_rule9s\        $    rc Cs||\}}t|\}}}}||}|rxd||krxt|||}t|} ||||}}t|||| || ||SdS)Nr)rrfrrr3) rrsrQrrrcrrfrrrrrheaviside_rulevs rc Cs|\}}td}t|||}|rRg}x|D]\}}}t||} t| rLq.t|ddkr |\} } | rt||| ||} | jr g} g} t | tj r| j } n | | xB| D]:}t |jst||d|}|r| |t|dfqW| | dft| ||} | t|||| ||q.Wt|dkrBt|||S|r|dSnZ|tjrt|}d}|||}|||}||jkrt|||t||||SdS)NrprSrT)rUrrrrFrZas_numer_denomr rgrJr]rTrrrrhrr2r$r^r-rrlrW)rrsrQrtrZwaysrrrrZsubrule_denomZ piecewiseZ could_be_zerorrrrrsubstitution_rulesX               rcCs|S)N)Zis_rational_function)rsrQrrrrscCs ||S)N)Zapart)rsrQrrrrscCsdS)NTr)rsrQrrrrscCs|S)N)ri)rsrQrrrrscs0tfdd|jDp.t|tjp.t|tjS)Nc3s|]}|jp|VqdS)N)Zis_Powr)rGrP)rQrrrIsz..)allrTrJrUrkr])rsrQr)rQrrs cCs|S)N)expand)rsrQrrrrscCs ttdd|tDdkS)Ncss|]}|jdVqdS)rN)rT)rGrarrrrIsz..rS)r^setZatomsr)rsrQrrrrscCs |jddS)NT)Ztrig)r )rsrQrrrrscCsX|d}|j}|j}|j}|j|krD|j|kr6t|St||jSnt|jf|SdS)Nr)Z variablesrrgrQr0r/rrs)rrsZdiff_variablesZundifferentiated_functionZintegrand_variablesrrrderivative_rules  r cCsP|\}}|dt|rL|dt|t|}t|t||||SdS)NrS)rfrUrrhrXr1r)rrsrQrrrr rewrites_rulesr cCst|S)N)r/)rrrr fallback_rulesrc sV|f}|tkr*t|dkr dSt|Sndt|<t|}fddfdd}ttttjttttttt tj ttj t tj ttjttttttttt tttjttttjttttjti tttttttt |tjtjt!t |tjtjt"t |tjtj#tj$tj%tj&t't |tjtjt(t)t*tt+t,|}t|=|S)aReturns the steps needed to compute an integral. 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, cos >>> 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. Nc s|j}t|trtSt|tjr&tjS|jkr6tjSxDtjtjtj tj tj tj tj tjtjtjtf D]}t||rf|SqfWdS)N)rsrJrrU Derivativergr_rkrrlrzr[r]ryrwrxr{r)rrsr)rQrrr&s    zintegral_steps..keycsfdd}|S)Ncs|}|ot|S)N) issubclass)rk)rklassesrr_integral_is_subclass8szKintegral_steps..integral_is_subclass.._integral_is_subclassr)rr)r)rrintegral_is_subclass7sz,integral_steps..integral_is_subclass)-_integral_cacherAr r r rUrkrrrrrlrr[rr]rrrrrr rrr{rrr_rr.r rr partial_fractions_rule cancel_rulerzryrwrxrdistribute_expand_rulertrig_expand_rulerr)rsrQZoptionsZcachekeyrrrr)rrQrrs^.           rcCs||S)Nr)rrsrQrrr eval_constantgsrcCs |t|S)N)r)rrrrsrQrrreval_constanttimesksrcCs2t||d|dt|dft|dfS)NrSrT)rUr rrz)rorlrsrQrrr eval_powerosrcCs|t|S)N)rUln)rorlrsrQrrreval_expvsrcCsttt|S)N)r\mapr)r#rsrQrrreval_addzsr cCst|}|||S)N)rrh)rtrrrrsrQrrrreval_u~sr!cCst|}||t|S)N)r)rprrZ second_steprsrQrrrr eval_partssr"cCsNd|}g}d}x.|D]&}|||jt|j|d9}qWtj||S)NrSr)rrprrrUr[)Z parts_rulesrrsrQrZsignrBrrreval_cyclicpartss  r#cCst|dkrt| S|dkr&t|S|dkr8t|S|dkrJt|S|dkr\t|S|dkrpt| SdS)Nrrzsec*tanzcsc*cotzsec**2zcsc**2)rUrrrXrZrVrY)r*rPrsrQrrr eval_trigs     r$cCs2||dt||t|t||S)NrS)rUrry)rarcrrsrQrrr eval_arctansr%cCs8| |dt| |t|t| |S)NrS)rUrZacoth)rarcrrsrQrrr eval_arccothsr&cCs8| |dt| |t|t| |S)NrS)rUrZatanh)rarcrrsrQrrr eval_arctanhsr'cCs t|S)N)rUr)r*rsrQrrreval_reciprocalsr(cCs t|S)N)rUrw)rsrQrrr eval_arcsinsr)cCs||S)Nr)r*rsrQrrreval_inversehyperbolicsr*cCs t|dS)Nr)r)r.rsrQrrreval_alternativesr+cCst|S)N)r)rrrsrQrrr eval_rewritesr,cCstjdd|DS)NcSsg|]\}}t||fqSr)r)rGrcondrrrrRsz"eval_piecewise..)rUr )r#rsrQrrreval_piecewises r.cCsx|t|dt|}t|t}t|dks:t|d}t |||}t|dksbtt |d\} } t |tj r| } | } t | d| d} t|d}ntt |tjr| } | } t | d| d} t|d}n:t |tjr"| } | } t | d| d} t|d}t || | ft|| | ft|| | f||fg}tt|||fS)NrSrrN)rhrUrXrrKrrr^AssertionErrorZsolveZfractionrJrrrwrxrVryr rr)rr*rrrrsrQZ trig_functionZrelationZnumerrZoppositeZ hypotenuseZadjacentZinverserrrreval_trigsubstitutions8   r0cCsPt|j}x2t|D]&\}\}}||kr||df||<PqWtj|jf|S)NrS)rKvariable_countrrUrr)rsrQr1rHvarcountrrreval_derivativerules  r4cCst|||||S)N)rUr{rh)ZhargZibndrrsrQrrreval_heavisidesr5cCs~tdt|d|d|d||||t|||df|t|df||d|dd|||dt|dfS)NrNrSrr)r rUrrr)r;rarcrsrQrrr eval_jacobis< r6cCsZtt|d|d|d|dt|dft|d||dt|dftjjdfS)NrSrNrT)r rUrrr|SZero)r;rarsrQrrreval_gegenbauers* r9cCsVtt|d||dt|d||ddtt|df|dddfS)NrSrNT)r rUr|rrm)r;rsrQrrreval_chebyshevts,r:cCs0tt|d||dt|dftjjdfS)NrSrT)r rUr|rr7r8)r;rsrQrrreval_chebyshevus r;cCs,t|d|t|d|d|dS)NrSrN)rUr~)r;rsrQrrr eval_legendresr<cCst|d|d|dS)NrSrN)rUr)r;rsrQrrr eval_hermitesr=cCst||t|d|S)NrS)rUr)r;rsrQrrr eval_laguerre"sr>cCst|d|d| S)NrS)rUr)r;rarsrQrrreval_assoclaguerre&sr?cCs t||S)N)rUr)rsrQrrreval_dontknowrule*sr@cCs(t|j}|s tdt|||S)NzCannot evaluate rule %s)rCrdr ValueErrorrepr)rBZ evaluatorrrrr.s rcCstt||}t|trt|jdkr|jdd}t|tr|jdddkr||jddtj |jf|jdddf}|S)amanualintegrate(f, var) Compute indefinite integral of a single variable using an algorithm that resembles what a student would do by hand. Unlike ``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 rNrrST) rrrJr r^rTrr*rUr)r`r2rr-rrrmanualintegrate5s.rC)r)__doc__Z __future__rr collectionsrrUZsympy.core.compatibilityrZsympy.core.logicrZ(sympy.functions.elementary.trigonometricrZ#sympy.functions.special.polynomialsrZ$sympy.functions.elementary.piecewiser Zsympy.strategies.corer r r r Zsympy.core.relationalrrZsympy.polys.polytoolsrr7r8rerrr r!r"r$r%r&r'r(r)r+r,r-r/r0r1r2r3r4r5r6r7r8r9r:r<r=r>r?r@rArCrErFrOrrrrr.rrrrrrrrrrrrrZcacheitrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r.r0r4r5r6r9r:r;r<r=r>r?r@rrCrrrrs8                                   JAL>)                   = :    { %