o
    §ƒðjÉ' ã                   @  s  U d Z ddlmZ ddlmZmZmZmZ ddlm	Z	m
Z
 ddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z m!Z!m"Z" ddl#m$Z$ ddl%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z,m-Z-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3 ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z< ddl=m>Z> ddl?m@Z@ ddlAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZN ddlOmPZPmQZQ ddlRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\ ddl]m^Z^ ddl_m`Z`maZa ddlbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZk ddllmmZm d d!lnmoZo dd"lpmqZq dd#lrmsZs dd$ltmuZumvZvmwZwmxZx dd%lymzZz dd&l{m|Z| dd'l}m~Z~ dd(lm€Z€m�Z�m‚Z‚mƒZƒ dd)l„m…Z… dd*l†m‡Z‡ eG d+d,„ d,e	ƒƒZˆeG d-d.„ d.eˆe	ƒƒZ‰eG d/d0„ d0e‰ƒƒZŠeG d1d2„ d2eˆƒƒZ‹eG d3d4„ d4e‰ƒƒZŒeG d5d6„ d6e‰ƒƒZ�eG d7d8„ d8eˆƒƒZŽeG d9d:„ d:eˆƒƒZ�eG d;d<„ d<eˆƒƒZ�eG d=d>„ d>eˆƒƒZ‘eG d?d@„ d@e‰e	ƒƒZ’eG dAdB„ dBe’ƒƒZ“eG dCdD„ dDe’ƒƒZ”eG dEdF„ dFe’ƒƒZ•eG dGdH„ dHe’ƒƒZ–eG dIdJ„ dJe’ƒƒZ—eG dKdL„ dLe’ƒƒZ˜eG dMdN„ dNe‰e	ƒƒZ™eG dOdP„ dPe™ƒƒZšeG dQdR„ dRe™ƒƒZ›eG dSdT„ dTe‰ƒƒZœeG dUdV„ dVe‰ƒƒZ�eG dWdX„ dXe‰ƒƒZžeG dYdZ„ dZe‰ƒƒZŸeG d[d\„ d\e‰ƒƒZ eG d]d^„ d^e‰ƒƒZ¡eG d_d`„ d`e‰ƒƒZ¢eG dadb„ dbeˆƒƒZ£eG dcdd„ ddeˆƒƒZ¤eG dedf„ dfe‰ƒƒZ¥eG dgdh„ dheˆƒƒZ¦eG didj„ dje¦ƒƒZ§eG dkdl„ dleˆƒƒZ¨eG dmdn„ dneˆƒƒZ©eG dodp„ dpe‰ƒƒZªeG dqdr„ dreˆƒƒZ«eG dsdt„ dte‰ƒƒZ¬eG dudv„ dve‰e	ƒƒZ­eG dwdx„ dxe­ƒƒZ®eG dydz„ dze­ƒƒZ¯eG d{d|„ d|e­ƒƒZ°eG d}d~„ d~e­ƒƒZ±eG dd€„ d€e­ƒƒZ²eG d�d‚„ d‚e­ƒƒZ³eG dƒd„„ d„e­ƒƒZ´eG d…d†„ d†e­ƒƒZµeG d‡dˆ„ dˆe‰e	ƒƒZ¶eG d‰dŠ„ dŠe¶ƒƒZ·eG d‹dŒ„ dŒe¶ƒƒZ¸eG d�dŽ„ dŽe¶ƒƒZ¹eG d�d�„ d�e¶ƒƒZºeG d‘d’„ d’e¶ƒƒZ»eG d“d”„ d”e¶ƒƒZ¼eG d•d–„ d–e‰ƒƒZ½eG d—d˜„ d˜e‰ƒƒZ¾eG d™dš„ dše‰ƒƒZ¿eG d›dœ„ dœe‰ƒƒZÀeG d�dž„ dže‰ƒƒZÁeG dŸd „ d e‰ƒƒZÂeG d¡d¢„ d¢e‰ƒƒZÃG d£d¤„ d¤eƒZÄd¥d¦„ ZÅd§d¨„ ZÆeKeJeIeLeMeNfZÇd©dª„ ZÈd«d¬„ ZÉd­d®„ ZÊd¯d°„ ZËd±d²„ ZÌd³d´„ ZÍdµd¶„ ZÎd·d¸„ ZÏd¹dº„ ZÐg ZÑd»eÒd¼< g ZÓe,d½ƒZÔd¾d¿„ ZÕ�d+dÄdÅ„ZÖ�d,dÇdÈ„Z×�d-�d,dÊdË„ZØdÌdÍ„ ZÙ�d,dÎdÏ„ZÚ�d.dÑdÒ„ZÛdÓdÔ„ ZÜdÕdÖ„ ZÝ�d,d×dØ„ZÞdÙdÚ„ Zß�d,dÛdÜ„Zà�d-�d,dÝdÞ„Zá�d/dàdá„Zâedâdã„ ƒZãedädå„ ƒZäedædç„ ƒZåedèdé„ ƒZæedêdë„ ƒZçdìdí„ Zèdîdï„ Zéeèdðdñ„ ƒZêeédòdñ„ ƒZëeèdódñ„ ƒZìeédôdñ„ ƒZíeèdõdñ„ ƒZîeédödñ„ ƒZïeèd÷dñ„ ƒZðeédødñ„ ƒZñeèdùdñ„ ƒZòeédúdñ„ ƒZóeèdûdñ„ ƒZôeédüdñ„ ƒZõeèdýdñ„ ƒZöeédþdñ„ ƒZ÷eèdÿdñ„ ƒZøeé�d dñ„ ƒZù�d�d„ Zú�d�d„ Zû�d�d„ Zü�d�d„ Zý�d	�d
„ Zþ�d�d„ Zÿ�d�d„ �Z �d,�d�d„�Z�d�d„ �ZeÉ�ddñ„ �ddñ„ ƒ�ZeÉ�ddñ„ �ddñ„ ƒ�ZeÉ�ddñ„ �ddñ„ ƒ�ZeÉ�ddñ„ �ddñ„ ƒ�Z�d�d„ �Z�d�d„ �Z�d�d „ �Z	i �Z
�d!eÒ�d"< e�eƒ�Z�d#eÒ�d$< e,�d%ƒ�Z�d&�d'„ �Z�d(�d)„ �Z�d*S (0  a/  Integration 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 ``Rule`` s representing the integration rules used.

Each ``Rule`` class represents a (maybe parametrized) integration rule, e.g.
``SinRule`` for integrating ``sin(x)`` and ``ReciprocalSqrtQuadraticRule``
for integrating ``1/sqrt(a+b*x+c*x**2)``. The ``eval`` method returns the
integration result.

The ``manualintegrate`` function computes the integral by calling ``eval``
on the rule returned by ``integral_steps``.

The integrator can be extended with new heuristics and evaluation
techniques. To do so, extend the ``Rule`` class, implement ``eval`` method,
then write a function that accepts an ``IntegralInfo`` object and returns
either a ``Rule`` instance or ``None``. 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.

é    )Úannotations)Ú
NamedTupleÚTypeÚCallableÚSequence)ÚABCÚabstractmethod)Ú	dataclass)Údefaultdict)ÚMapping)ÚAdd)Úcacheit)ÚDict)ÚExpr)Ú
Derivative)Ú	fuzzy_not)ÚMul)ÚIntegerÚNumberÚE)ÚPow)ÚEqÚNeÚBoolean)ÚS)ÚDummyÚSymbolÚWild)ÚAbs)ÚexpÚlog)ÚHyperbolicFunctionÚcschÚcoshÚcothÚsechÚsinhÚtanhÚasinh)Úsqrt)Ú	Piecewise)ÚTrigonometricFunctionÚcosÚsinÚtanÚcotÚcscÚsecÚacosÚasinÚatanÚacotÚacscÚasec)Ú	HeavisideÚ
DiracDelta)
ÚerfÚerfiÚfresnelcÚfresnelsÚCiÚChiÚSiÚShiÚEiÚli)Ú
uppergamma)Ú
elliptic_eÚ
elliptic_f)	Ú
chebyshevtÚ
chebyshevuÚlegendreÚhermiteÚlaguerreÚassoc_laguerreÚ
gegenbauerÚjacobiÚOrthogonalPolynomial)Úpolylogé   )ÚIntegral)ÚAnd)Úprimefactors)ÚdegreeÚlcm_listÚgcd_listÚPoly)Úfraction©Úsimplify)Úsolve)ÚswitchÚdo_oneÚ	null_safeÚ	condition)Úiterable)Údebugc                   @  s:   e Zd ZU ded< ded< eddd„ƒZedd	d
„ƒZdS )ÚRuler   Ú	integrandr   ÚvariableÚreturnc                 C  ó   d S ©N© ©Úselfri   ri   ú¡/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/integrals/manualintegrate.pyÚevalM   ó   z	Rule.evalÚboolc                 C  rg   rh   ri   rj   ri   ri   rl   Úcontains_dont_knowQ   rn   zRule.contains_dont_knowN©rf   r   ©rf   ro   )Ú__name__Ú
__module__Ú__qualname__Ú__annotations__r   rm   rp   ri   ri   ri   rl   rc   H   s   
 rc   c                   @  ó   e Zd ZdZddd„ZdS )Ú
AtomicRulez1A simple rule that does not depend on other rulesrf   ro   c                 C  ó   dS )NFri   rj   ri   ri   rl   rp   Y   ó   zAtomicRule.contains_dont_knowNrr   )rs   rt   ru   Ú__doc__rp   ri   ri   ri   rl   rx   V   ó    rx   c                   @  rw   )ÚConstantRulezintegrate(a, x)  ->  a*xrf   r   c                 C  s   | j | j S rh   )rd   re   rj   ri   ri   rl   rm   `   ó   zConstantRule.evalNrq   ©rs   rt   ru   r{   rm   ri   ri   ri   rl   r}   ]   r|   r}   c                   @  s>   e Zd ZU dZded< ded< ded< ddd	„Zddd„ZdS )ÚConstantTimesRulez.integrate(a*f(x), x)  ->  a*integrate(f(x), x)r   ÚconstantÚotherrc   Úsubsteprf   c                 C  s   | j | j ¡  S rh   )r�   rƒ   rm   rj   ri   ri   rl   rm   k   ó   zConstantTimesRule.evalro   c                 C  ó
   | j  ¡ S rh   ©rƒ   rp   rj   ri   ri   rl   rp   n   ó   
z$ConstantTimesRule.contains_dont_knowNrq   rr   ©rs   rt   ru   r{   rv   rm   rp   ri   ri   ri   rl   r€   d   s   
 
r€   c                   @  ó,   e Zd ZU dZded< ded< d	dd„ZdS )
Ú	PowerRulezintegrate(x**a, x)r   Úbaser   rf   c                 C  s6   t | j| jd  | jd  t| jdƒft| jƒdfƒS ©NrQ   éÿÿÿÿT)r*   r‹   r   r   r    rj   ri   ri   rl   rm   x   s   $þzPowerRule.evalNrq   ©rs   rt   ru   r{   rv   rm   ri   ri   ri   rl   rŠ   r   ó
   
 rŠ   c                   @  r‰   )
ÚNestedPowRulezintegrate((x**a)**b, x)r   r‹   r   rf   c                 C  s:   | j | j }t|| jd  t| jdƒf|t| j ƒ dfƒS rŒ   )r‹   rd   r*   r   r   r    )rk   Úmri   ri   rl   rm   …   s   ÿzNestedPowRule.evalNrq   rŽ   ri   ri   ri   rl   r�      r�   r�   c                   @  ó.   e Zd ZU dZded< ddd„Zdd	d
„ZdS )ÚAddRulezDintegrate(f(x) + g(x), x) -> integrate(f(x), x) + integrate(g(x), x)ú
list[Rule]Úsubstepsrf   r   c                 C  ó   t dd„ | jD ƒŽ S )Nc                 s  ó   � | ]}|  ¡ V  qd S rh   ©rm   ©Ú.0rƒ   ri   ri   rl   Ú	<genexpr>‘   ó   € zAddRule.eval.<locals>.<genexpr>)r   r•   rj   ri   ri   rl   rm   �   ó   zAddRule.evalro   c                 C  ó   t dd„ | jD ƒƒS )Nc                 s  r—   rh   ©rp   r™   ri   ri   rl   r›   ”   rœ   z-AddRule.contains_dont_know.<locals>.<genexpr>)Úanyr•   rj   ri   ri   rl   rp   “   r�   zAddRule.contains_dont_knowNrq   rr   rˆ   ri   ri   ri   rl   r“   ‹   ó
   
 
r“   c                   @  s>   e Zd ZU dZded< ded< ded< dd	d
„Zddd„ZdS )ÚURulez;integrate(f(g(x))*g'(x), x) -> integrate(f(u), u), u = g(x)r   Úu_varr   Úu_funcrc   rƒ   rf   c                 C  sP   | j  ¡ }| jjr | j ¡ \}}|dkr | t| jƒt|ƒ ¡}| | j| j¡S )Nr�   )rƒ   rm   r¤   Úis_PowÚas_base_expÚsubsr    r£   )rk   Úresultr‹   Úexp_ri   ri   rl   rm   ž   s   
z
URule.evalro   c                 C  r…   rh   r†   rj   ri   ri   rl   rp   §   r‡   zURule.contains_dont_knowNrq   rr   rˆ   ri   ri   ri   rl   r¢   —   s   
 
	r¢   c                   @  sF   e Zd ZU dZded< ded< ded< ded	< ddd„Zddd„ZdS )Ú	PartsRulez@integrate(u(x)*v'(x), x) -> u(x)*v(x) - integrate(u'(x)*v(x), x)r   Úur   Údvrc   Úv_stepúRule | NoneÚsecond_steprf   c                 C  s,   | j d usJ ‚| j ¡ }| j| | j  ¡  S rh   )r¯   r­   rm   r«   )rk   Úvri   ri   rl   rm   ³   s   
zPartsRule.evalro   c                 C  s   | j  ¡ p| jd uo| j ¡ S rh   )r­   rp   r¯   rj   ri   ri   rl   rp   ¸   s   
ÿzPartsRule.contains_dont_knowNrq   rr   rˆ   ri   ri   ri   rl   rª   «   s   
 
rª   c                   @  ó6   e Zd ZU dZded< ded< ddd„Zdd
d„ZdS )ÚCyclicPartsRulez9Apply PartsRule multiple times to integrate exp(x)*sin(x)zlist[PartsRule]Úparts_rulesr   Úcoefficientrf   c                 C  sH   g }d}| j D ]}| ||j |j ¡  ¡ |d9 }qt|Ž d| j  S )NrQ   r�   )r³   Úappendr«   r­   rm   r   r´   )rk   r¨   ÚsignÚruleri   ri   rl   rm   Ã   s   

zCyclicPartsRule.evalro   c                 C  rž   )Nc                 s  r—   rh   rŸ   r™   ri   ri   rl   r›   Ì   rœ   z5CyclicPartsRule.contains_dont_know.<locals>.<genexpr>)r    r³   rj   ri   ri   rl   rp   Ë   r�   z"CyclicPartsRule.contains_dont_knowNrq   rr   rˆ   ri   ri   ri   rl   r²   ½   s   
 
r²   c                   @  ó   e Zd ZdS )ÚTrigRuleN©rs   rt   ru   ri   ri   ri   rl   r¹   Ï   ó    r¹   c                   @  rw   )ÚSinRulezintegrate(sin(x), x) -> -cos(x)rf   r   c                 C  ó   t | jƒ S rh   )r,   re   rj   ri   ri   rl   rm   ×   r~   zSinRule.evalNrq   r   ri   ri   ri   rl   r¼   Ô   r|   r¼   c                   @  rw   )ÚCosRulezintegrate(cos(x), x) -> sin(x)rf   r   c                 C  ó
   t | jƒS rh   )r-   re   rj   ri   ri   rl   rm   Þ   r‡   zCosRule.evalNrq   r   ri   ri   ri   rl   r¾   Û   r|   r¾   c                   @  rw   )Ú
SecTanRulez%integrate(sec(x)*tan(x), x) -> sec(x)rf   r   c                 C  r¿   rh   )r1   re   rj   ri   ri   rl   rm   å   r‡   zSecTanRule.evalNrq   r   ri   ri   ri   rl   rÀ   â   r|   rÀ   c                   @  rw   )Ú
CscCotRulez&integrate(csc(x)*cot(x), x) -> -csc(x)rf   r   c                 C  r½   rh   )r0   re   rj   ri   ri   rl   rm   ì   r~   zCscCotRule.evalNrq   r   ri   ri   ri   rl   rÁ   é   r|   rÁ   c                   @  rw   )ÚSec2Rulez!integrate(sec(x)**2, x) -> tan(x)rf   r   c                 C  r¿   rh   )r.   re   rj   ri   ri   rl   rm   ó   r‡   zSec2Rule.evalNrq   r   ri   ri   ri   rl   rÂ   ð   r|   rÂ   c                   @  rw   )ÚCsc2Rulez"integrate(csc(x)**2, x) -> -cot(x)rf   r   c                 C  r½   rh   )r/   re   rj   ri   ri   rl   rm   ú   r~   zCsc2Rule.evalNrq   r   ri   ri   ri   rl   rÃ   ÷   r|   rÃ   c                   @  r¸   )ÚHyperbolicRuleNrº   ri   ri   ri   rl   rÄ   þ   r»   rÄ   c                   @  rw   )ÚSinhRulez integrate(sinh(x), x) -> cosh(x)rf   r   c                 C  r¿   rh   )r#   re   rj   ri   ri   rl   rm     r‡   zSinhRule.evalNrq   r   ri   ri   ri   rl   rÅ     r|   rÅ   c                   @  s   e Zd ZdZdd„ ZdS )ÚCoshRulez integrate(cosh(x), x) -> sinh(x)c                 C  r¿   rh   )r&   re   rj   ri   ri   rl   rm     r‡   zCoshRule.evalNr   ri   ri   ri   rl   rÆ   
  s    rÆ   c                   @  r‰   )
ÚExpRulez integrate(a**x, x) -> a**x/ln(a)r   r‹   r   rf   c                 C  s   | j t| jƒ S rh   )rd   r    r‹   rj   ri   ri   rl   rm     r„   zExpRule.evalNrq   rŽ   ri   ri   ri   rl   rÇ     r�   rÇ   c                   @  s$   e Zd ZU dZded< ddd„ZdS )	ÚReciprocalRulezintegrate(1/x, x) -> ln(x)r   r‹   rf   c                 C  r¿   rh   )r    r‹   rj   ri   ri   rl   rm      r‡   zReciprocalRule.evalNrq   rŽ   ri   ri   ri   rl   rÈ     s   
 rÈ   c                   @  rw   )Ú
ArcsinRulez'integrate(1/sqrt(1-x**2), x) -> asin(x)rf   r   c                 C  r¿   rh   )r3   re   rj   ri   ri   rl   rm   '  r‡   zArcsinRule.evalNrq   r   ri   ri   ri   rl   rÉ   $  r|   rÉ   c                   @  rw   )ÚArcsinhRulez'integrate(1/sqrt(1+x**2), x) -> asin(x)rf   r   c                 C  r¿   rh   )r(   re   rj   ri   ri   rl   rm   .  r‡   zArcsinhRule.evalNrq   r   ri   ri   ri   rl   rÊ   +  r|   rÊ   c                   @  ó4   e Zd ZU dZded< ded< ded< d
dd„Zd	S )ÚReciprocalSqrtQuadraticRulezWintegrate(1/sqrt(a+b*x+c*x**2), x) -> log(2*sqrt(c)*sqrt(a+b*x+c*x**2)+b+2*c*x)/sqrt(c)r   ÚaÚbÚcrf   c                 C  s`   | j | j| j| jf\}}}}tdt|ƒ t|||  ||d   ƒ | d| |  ƒt|ƒ S )Né   )rÍ   rÎ   rÏ   re   r    r)   ©rk   rÍ   rÎ   rÏ   Úxri   ri   rl   rm   9  s   Dz ReciprocalSqrtQuadraticRule.evalNrq   rŽ   ri   ri   ri   rl   rÌ   2  ó   
 rÌ   c                   @  s<   e Zd ZU dZded< ded< ded< ded< dd	d
„ZdS )ÚSqrtQuadraticDenomRulez(integrate(poly(x)/sqrt(a+b*x+c*x**2), x)r   rÍ   rÎ   rÏ   z
list[Expr]Úcoeffsrf   c                   sd  | j | j| j| j ¡ | jf\}}}‰ ‰g ‰ˆ  ¡ ‰ ttˆ ƒd ƒD ];}tˆ ƒd | }ˆ | ||  }ˆ |¡ ˆ |d   d| d | d | 8  < ˆ |d   |d | | 8  < q!ˆ d ˆ d }}t	||ˆ  |ˆd   ƒ}	||| d|   }
|
dkr…d}nt
td|	 ˆƒdd�}|
| ¡  }tg ‡ ‡‡fdd	„ttˆƒƒD ƒ¢|| ‘R Ž |	 | S )
NrÐ   rQ   r�   éþÿÿÿr   F©Ú
degeneratec                 3  s,   � | ]}ˆ| ˆt ˆ ƒd  |   V  qdS )rÐ   N)Úlen©rš   Úi©rÕ   Úresult_coeffsrÒ   ri   rl   r›   ^  s   € $ÿz.SqrtQuadraticDenomRule.eval.<locals>.<genexpr>)rÍ   rÎ   rÏ   rÕ   Úcopyre   ÚrangerÙ   rµ   r)   Úinverse_trig_ruleÚIntegralInform   r   )rk   rÍ   rÎ   rÏ   rÛ   ÚnÚcoeffÚdÚeÚsr�   ÚI0Ústepri   rÜ   rl   rm   F  s2   &
("
ÿÿÿÿzSqrtQuadraticDenomRule.evalNrq   rŽ   ri   ri   ri   rl   rÔ   >  s   
 rÔ   c                   @  rË   )ÚSqrtQuadraticRulez integrate(sqrt(a+b*x+c*x**2), x)r   rÍ   rÎ   rÏ   rf   c                 C  s   t t| j| jƒdd�}| ¡ S )NFr×   )Úsqrt_quadratic_rulerá   rd   re   rm   )rk   rè   ri   ri   rl   rm   i  s   zSqrtQuadraticRule.evalNrq   rŽ   ri   ri   ri   rl   ré   b  rÓ   ré   c                   @  r’   )ÚAlternativeRulez Multiple ways to do integration.r”   Úalternativesrf   r   c                 C  s   | j d  ¡ S ©Nr   )rì   rm   rj   ri   ri   rl   rm   s  ó   zAlternativeRule.evalro   c                 C  rž   )Nc                 s  r—   rh   rŸ   r™   ri   ri   rl   r›   w  rœ   z5AlternativeRule.contains_dont_know.<locals>.<genexpr>)r    rì   rj   ri   ri   rl   rp   v  r�   z"AlternativeRule.contains_dont_knowNrq   rr   rˆ   ri   ri   ri   rl   rë   n  r¡   rë   c                   @  s$   e Zd ZdZd
dd„Zddd„Zd	S )ÚDontKnowRulezLeave the integral as is.rf   r   c                 C  s   t | j| jƒS rh   )rR   rd   re   rj   ri   ri   rl   rm   }  rî   zDontKnowRule.evalro   c                 C  ry   ©NTri   rj   ri   ri   rl   rp   €  rz   zDontKnowRule.contains_dont_knowNrq   rr   )rs   rt   ru   r{   rm   rp   ri   ri   ri   rl   rï   z  s    
rï   c                   @  rw   )ÚDerivativeRulezintegrate(f'(x), x) -> f(x)rf   r   c                 C  sd   t | jtƒsJ ‚t| jjƒ}t|ƒD ]\}\}}|| jkr'||d f||<  nqt| jjg|¢R Ž S ©NrQ   )Ú
isinstancerd   r   ÚlistÚvariable_countÚ	enumeratere   Úexpr)rk   rõ   rÛ   ÚvarÚcountri   ri   rl   rm   ‡  s   
þzDerivativeRule.evalNrq   r   ri   ri   ri   rl   rñ   „  r|   rñ   c                   @  r±   )ÚRewriteRulez;Rewrite integrand to another form that is easier to handle.r   Ú	rewrittenrc   rƒ   rf   c                 C  r…   rh   )rƒ   rm   rj   ri   ri   rl   rm   —  r‡   zRewriteRule.evalro   c                 C  r…   rh   r†   rj   ri   ri   rl   rp   š  r‡   zRewriteRule.contains_dont_knowNrq   rr   rˆ   ri   ri   ri   rl   rú   ‘  s   
 
rú   c                   @  s   e Zd ZdZdS )ÚCompleteSquareRulez7Rewrite a+b*x+c*x**2 to a-b**2/(4*c) + c*(x+b/(2*c))**2N)rs   rt   ru   r{   ri   ri   ri   rl   rü   ž  s    rü   c                   @  s*   e Zd ZU ded< ddd„Zddd	„Zd
S )ÚPiecewiseRulez%Sequence[tuple[Rule, bool | Boolean]]Úsubfunctionsrf   r   c                 C  r–   )Nc                 S  s   g | ]
\}}|  ¡ |f‘qS ri   r˜   ©rš   rƒ   Úcondri   ri   rl   Ú
<listcomp>©  s    ÿz&PiecewiseRule.eval.<locals>.<listcomp>)r*   rþ   rj   ri   ri   rl   rm   ¨  s   ÿzPiecewiseRule.evalro   c                 C  rž   )Nc                 s  s   � | ]	\}}|  ¡ V  qd S rh   rŸ   )rš   rƒ   Ú_ri   ri   rl   r›   ­  s   € z3PiecewiseRule.contains_dont_know.<locals>.<genexpr>)r    rþ   rj   ri   ri   rl   rp   ¬  r�   z PiecewiseRule.contains_dont_knowNrq   rr   ©rs   rt   ru   rv   rm   rp   ri   ri   ri   rl   rý   ¤  s   
 
rý   c                   @  s:   e Zd ZU ded< ded< ded< ddd„Zdd
d„ZdS )ÚHeavisideRuler   ÚhargÚibndrc   rƒ   rf   c                 C  s(   | j  ¡ }t| jƒ|| | j| j¡  S rh   )rƒ   rm   r8   r  r§   re   r  )rk   r¨   ri   ri   rl   rm   ¶  s   
zHeavisideRule.evalro   c                 C  r…   rh   r†   rj   ri   ri   rl   rp   ¾  r‡   z HeavisideRule.contains_dont_knowNrq   rr   r  ri   ri   ri   rl   r  °  s   
 
r  c                   @  ó0   e Zd ZU ded< ded< ded< d	dd„ZdS )
ÚDiracDeltaRuler   râ   rÍ   rÎ   rf   c                 C  sR   | j | j| j| jf\}}}}|dkrt|||  ƒ| S t|||  |d ƒ| S ©Nr   rQ   )râ   rÍ   rÎ   re   r8   r9   ©rk   râ   rÍ   rÎ   rÒ   ri   ri   rl   rm   È  s   zDiracDeltaRule.evalNrq   ©rs   rt   ru   rv   rm   ri   ri   ri   rl   r  Â  ó
   
 r  c                   @  sJ   e Zd ZU ded< ded< ded< ded< ded< dd
d„Zddd„ZdS )ÚTrigSubstitutionRuler   ÚthetaÚfuncrû   rc   rƒ   zbool | BooleanÚrestrictionrf   c                 C  s”  | j | j| j}}}| t|ƒdt|ƒ ¡}| t|ƒdt|ƒ ¡}| t|ƒdt	|ƒ ¡}t
| t¡ƒ}t|ƒdks>J ‚|d }t|| |ƒ}t|ƒdksQJ ‚t|d ƒ\}}t|tƒrs|}|}	t|d |d  ƒ}
t|d ƒ}n.t|tƒr�|}
|}	t|d |d  ƒ}t|d ƒ}n|}|}
t|d |d  ƒ}	t|d ƒ}t|ƒ||	 ft|ƒ|
|	 ft	|ƒ||
 f||fg}t| j ¡  |¡ ¡ | jfƒS )NrQ   r   rÐ   )r  r  re   r§   r1   r,   r0   r-   r/   r.   rô   Úfindr+   rÙ   r\   rY   ró   r)   r3   r2   r4   r*   rƒ   rm   Útrigsimpr  )rk   r  r  rÒ   Útrig_functionÚrelationÚnumerÚdenomÚoppositeÚ
hypotenuseÚadjacentÚinverseÚsubstitutionri   ri   rl   rm   ×  s@   

üÿzTrigSubstitutionRule.evalro   c                 C  r…   rh   r†   rj   ri   ri   rl   rp   þ  r‡   z'TrigSubstitutionRule.contains_dont_knowNrq   rr   r  ri   ri   ri   rl   r  Ï  s   
 
'r  c                   @  rË   )Ú
ArctanRulezAintegrate(a/(b*x**2+c), x) -> a/b / sqrt(c/b) * atan(x/sqrt(c/b))r   rÍ   rÎ   rÏ   rf   c                 C  sD   | j | j| j| jf\}}}}|| t|| ƒ t|t|| ƒ ƒ S rh   )rÍ   rÎ   rÏ   re   r)   r4   rÑ   ri   ri   rl   rm   	  s   (zArctanRule.evalNrq   rŽ   ri   ri   ri   rl   r    rÓ   r  c                   @  s   e Zd ZU ded< dS )ÚOrthogonalPolyRuler   râ   N©rs   rt   ru   rv   ri   ri   ri   rl   r    s   
 r  c                   @  ó(   e Zd ZU ded< ded< ddd„ZdS )	Ú
JacobiRuler   rÍ   rÎ   rf   c                 C  s˜   | j | j| j| jf\}}}}tdt|d |d |d |ƒ || |  t|| | dƒf|t|dƒf|| d |d  d || | d  t|dƒfƒS )NrÐ   rQ   r   é   )râ   rÍ   rÎ   re   r*   rN   r   r   r
  ri   ri   rl   rm     s   :0ýzJacobiRule.evalNrq   r  ri   ri   ri   rl   r     ó   
 r   c                   @  ó    e Zd ZU ded< ddd„ZdS )ÚGegenbauerRuler   rÍ   rf   c                 C  sj   | j | j| j}}}tt|d |d |ƒd|d   t|dƒft|d |ƒ|d  t|dƒftjdfƒS )NrQ   rÐ   r�   T)	râ   rÍ   re   r*   rM   r   rG   r   ÚZero)rk   râ   rÍ   rÒ   ri   ri   rl   rm   $  s   (ýzGegenbauerRule.evalNrq   r  ri   ri   ri   rl   r$     ó   
 r$  c                   @  ó   e Zd Zddd„ZdS )ÚChebyshevTRulerf   r   c                 C  s^   | j | j}}tt|d |ƒ|d  t|d |ƒ|d   d tt|ƒdƒf|d d dfƒS )NrQ   rÐ   T)râ   re   r*   rG   r   r   ©rk   râ   rÒ   ri   ri   rl   rm   .  s   ÿÿÿýzChebyshevTRule.evalNrq   ©rs   rt   ru   rm   ri   ri   ri   rl   r(  ,  ó    r(  c                   @  r'  )ÚChebyshevURulerf   r   c                 C  s:   | j | j}}tt|d |ƒ|d  t|dƒftjdfƒS rŒ   )râ   re   r*   rG   r   r   r%  r)  ri   ri   rl   rm   8  s
   þzChebyshevURule.evalNrq   r*  ri   ri   ri   rl   r,  6  r+  r,  c                   @  r'  )ÚLegendreRulerf   r   c                 C  s6   | j | j}}t|d |ƒt|d |ƒ d| d  S ©NrQ   rÐ   )râ   re   rI   r)  ri   ri   rl   rm   A  s   (zLegendreRule.evalNrq   r*  ri   ri   ri   rl   r-  ?  r+  r-  c                   @  r'  )ÚHermiteRulerf   r   c                 C  s(   | j | j}}t|d |ƒd|d   S r.  )râ   re   rJ   r)  ri   ri   rl   rm   H  s   zHermiteRule.evalNrq   r*  ri   ri   ri   rl   r/  F  r+  r/  c                   @  r'  )ÚLaguerreRulerf   r   c                 C  s&   | j | j}}t||ƒt|d |ƒ S rò   )râ   re   rK   r)  ri   ri   rl   rm   O  s   zLaguerreRule.evalNrq   r*  ri   ri   ri   rl   r0  M  r+  r0  c                   @  r#  )ÚAssocLaguerreRuler   rÍ   rf   c                 C  s   t | jd | jd | jƒ S rò   )rL   râ   rÍ   re   rj   ri   ri   rl   rm   X  ó   zAssocLaguerreRule.evalNrq   r  ri   ri   ri   rl   r1  T  r&  r1  c                   @  s   e Zd ZU ded< ded< dS )ÚIRuler   rÍ   rÎ   Nr  ri   ri   ri   rl   r3  \  s   
 r3  c                   @  r'  )ÚCiRulerf   r   c                 C  s>   | j | j| j}}}t|ƒt|| ƒ t|ƒt|| ƒ  S rh   )rÍ   rÎ   re   r,   r>   r-   r@   ©rk   rÍ   rÎ   rÒ   ri   ri   rl   rm   d  ó   (zCiRule.evalNrq   r*  ri   ri   ri   rl   r4  b  r+  r4  c                   @  r'  )ÚChiRulerf   r   c                 C  ó>   | j | j| j}}}t|ƒt|| ƒ t|ƒt|| ƒ  S rh   )rÍ   rÎ   re   r#   r?   r&   rA   r5  ri   ri   rl   rm   k  r6  zChiRule.evalNrq   r*  ri   ri   ri   rl   r7  i  r+  r7  c                   @  r'  )ÚEiRulerf   r   c                 C  s*   | j | j| j}}}t|ƒt|| ƒ S rh   )rÍ   rÎ   re   r   rB   r5  ri   ri   rl   rm   r  ó   zEiRule.evalNrq   r*  ri   ri   ri   rl   r9  p  r+  r9  c                   @  r'  )ÚSiRulerf   r   c                 C  r8  rh   )rÍ   rÎ   re   r-   r>   r,   r@   r5  ri   ri   rl   rm   y  r6  zSiRule.evalNrq   r*  ri   ri   ri   rl   r;  w  r+  r;  c                   @  r'  )ÚShiRulerf   r   c                 C  r8  rh   )rÍ   rÎ   re   r&   r?   r#   rA   r5  ri   ri   rl   rm   €  r6  zShiRule.evalNrq   r*  ri   ri   ri   rl   r<  ~  r+  r<  c                   @  r'  )ÚLiRulerf   r   c                 C  s*   | j | j| j}}}t|| | ƒ| S rh   )rÍ   rÎ   re   rC   r5  ri   ri   rl   rm   ‡  r:  zLiRule.evalNrq   r*  ri   ri   ri   rl   r=  …  r+  r=  c                   @  r  )
ÚErfRuler   rÍ   rÎ   rÏ   rf   c                 C  s  | j | j| j| jf\}}}}|jrhtttjƒt| ƒ d t	||d d|   ƒ t
d| | | dt| ƒ  ƒ |dk fttjƒt|ƒ d t	||d d|   ƒ td| | | dt|ƒ  ƒ dfƒS ttjƒt|ƒ d t	||d d|   ƒ td| | | dt|ƒ  ƒ S )NrÐ   r!  rÖ   r   T)rÍ   rÎ   rÏ   re   Úis_extended_realr*   r)   r   ÚPir   r:   r;   rÑ   ri   ri   rl   rm   ’  s"   . ÿÿ,ÿÿý,ÿzErfRule.evalNrq   r  ri   ri   ri   rl   r>  Œ  r  r>  c                   @  r  )
ÚFresnelCRuler   rÍ   rÎ   rÏ   rf   c                 C  s®   | j | j| j| jf\}}}}ttjƒtd| ƒ t|d d|  | ƒtd| | | td| tj ƒ ƒ t	|d d|  | ƒt
d| | | td| tj ƒ ƒ   S ©NrÐ   r!  )rÍ   rÎ   rÏ   re   r)   r   r@  r,   r<   r-   r=   rÑ   ri   ri   rl   rm   ¤  ó   <<ÿÿzFresnelCRule.evalNrq   r  ri   ri   ri   rl   rA  ž  r  rA  c                   @  r  )
ÚFresnelSRuler   rÍ   rÎ   rÏ   rf   c                 C  s®   | j | j| j| jf\}}}}ttjƒtd| ƒ t|d d|  | ƒtd| | | td| tj ƒ ƒ t	|d d|  | ƒt
d| | | td| tj ƒ ƒ   S rB  )rÍ   rÎ   rÏ   re   r)   r   r@  r,   r=   r-   r<   rÑ   ri   ri   rl   rm   ±  rC  zFresnelSRule.evalNrq   r  ri   ri   ri   rl   rD  «  r  rD  c                   @  r  )	ÚPolylogRuler   rÍ   rÎ   rf   c                 C  s   t | jd | j| j ƒS rò   )rP   rÎ   rÍ   re   rj   ri   ri   rl   rm   ½  s   zPolylogRule.evalNrq   r  ri   ri   ri   rl   rE  ¸  r"  rE  c                   @  r  )	ÚUpperGammaRuler   rÍ   rå   rf   c                 C  sF   | j | j| j}}}|| | | |   t|d | | ƒ | S rò   )rÍ   rå   re   rD   )rk   rÍ   rå   rÒ   ri   ri   rl   rm   Æ  s   0zUpperGammaRule.evalNrq   r  ri   ri   ri   rl   rF  Á  r"  rF  c                   @  r  )	ÚEllipticFRuler   rÍ   rä   rf   c                 C  s   t | j| j| j ƒt| jƒ S rh   )rF   re   rä   rÍ   r)   rj   ri   ri   rl   rm   Ð  ó   zEllipticFRule.evalNrq   r  ri   ri   ri   rl   rG  Ë  r"  rG  c                   @  r  )	ÚEllipticERuler   rÍ   rä   rf   c                 C  s   t | j| j| j ƒt| jƒ S rh   )rE   re   rä   rÍ   r)   rj   ri   ri   rl   rm   Ù  rH  zEllipticERule.evalNrq   r  ri   ri   ri   rl   rI  Ô  r"  rI  c                   @  s   e Zd ZU ded< ded< dS )rá   r   rd   r   ÚsymbolNr  ri   ri   ri   rl   rá   Ý  s   
 rá   c                   s
  | j r€| j d }t| tƒr| ˆ ¡t|ƒd  S t| tƒr)| ˆ ¡ t|ƒd  S t| tƒr;| ˆ ¡t|ƒ t|ƒ S t| tƒrN| ˆ ¡ t|ƒ t|ƒ S t| tƒr_t‡ fdd„| j D ƒƒS t| t	ƒr€t
| j ƒdkr€t| j d tƒr€| j d t| j d ˆ ƒ S |  ˆ ¡S )a  Derivative of f in form expected by find_substitutions

    SymPy's derivatives for some trig functions (like cot) are not in a form
    that works well with finding substitutions; this replaces the
    derivatives for those particular forms with something that works better.

    r   rÐ   c                 3  ó   � | ]}t |ˆ ƒV  qd S rh   )Úmanual_diff©rš   Úarg©rJ  ri   rl   r›   õ  ó   € zmanual_diff.<locals>.<genexpr>rQ   )Úargsró   r.   Údiffr1   r/   r0   r   Úsumr   rÙ   r   rL  )ÚfrJ  rN  ri   rO  rl   rL  â  s    







rL  c                   sÀ   t |ƒdkr|d }t|ttfƒr| ¡ }nt|ƒstdƒ‚nt |ƒdkr)|g}ntdƒ‚g }|D ]%\}‰ t|tƒrV|jd ‰|  	‡fdd„‡ fdd„¡} | 
ˆtˆ ƒf¡ q1|  t|ƒ| ¡S )	zn
    A wrapper for `expr.subs(*args)` with additional logic for substitution
    of invertible functions.
    rQ   r   z(Expected an iterable of (old, new) pairsrÐ   z$subs accepts either 1 or 2 argumentsc                   s   | j o| jˆ kS rh   )r¥   r‹   ©rÒ   )Úx0ri   rl   Ú<lambda>  ó    zmanual_subs.<locals>.<lambda>c                   s   t | j ˆ  ƒS rh   )r   rU  )Únewri   rl   rW    ó    )rÙ   ró   r   r   Úitemsra   Ú
ValueErrorr    rQ  Úreplacerµ   r   r§   rô   )r÷   rQ  ÚsequenceÚnew_subsÚoldri   )rY  rV  rl   Úmanual_subsû  s(   
ÿ


ÿ€ra  c                   s°   g }‡ ‡‡fdd„}d
‡fdd„}‡‡fdd„‰t t ˆˆ ƒ|ˆ ƒ ¡ƒD ]0}|ˆkr,q%t|ˆƒ}|||ƒ}|d	urU|\}	}|ˆ  ˆˆ¡krGq%||	|f}
|
|vrU| |
¡ q%|S )Nc                   s¦   |dkrdS ˆ | }t d || ˆ¡ƒ t|| ˆƒ ¡ }| ˆ¡r"dS ˆ  ˆ¡rL| ˆ¡rLt‡fdd„ˆ  ¡ D ƒƒ}t‡fdd„| ¡ D ƒƒ}||krLdS |jˆdd�S )Nr   Fz!substituted: {}, u: {}, u_var: {}c                 3  rK  rh   ©rU   ©rš   ÚtrO  ri   rl   r›   -  rP  z;find_substitutions.<locals>.test_subterm.<locals>.<genexpr>c                 3  rK  rh   rb  rc  )r£   ri   rl   r›   .  rP  )Úas_Add)	rb   Úformatra  ÚcancelÚhas_freeÚis_rational_functionÚmaxÚas_numer_denomÚas_independent)r«   Úu_diffÚsubstitutedÚ
deg_beforeÚ	deg_after)rd   rJ  r£   ri   rl   Útest_subterm"  s   
z(find_substitutions.<locals>.test_subtermÚtermr   c                   sŠ   g }g }t ddd„ gd�}|  t¡D ]#}|jd }ˆ |jvrq| |ˆ  ¡}|r0| || ¡ q| |¡ q|rC| tt|ƒˆ  ƒ¡ |S )Nrâ   c                 S  s   | j S rh   )Ú
is_Integer©râ   ri   ri   rl   rW  6  ó    z:find_substitutions.<locals>.exp_subterms.<locals>.<lambda>©Ú
propertiesr   )r   r  r   rQ  Úfree_symbolsÚmatchrµ   rW   )rr  Úlinear_coeffsÚtermsrâ   r©   rN  ry  rO  ri   rl   Úexp_subterms3  s   

z(find_substitutions.<locals>.exp_subtermsc                   sV  t ˆ ttgt¢t‘t‘t‘R ƒrˆ jd gS t ˆ tt	t
ttfƒr&ˆ jd gS t ˆ ttfƒr3ˆ jd gS t ˆ tƒr>ˆ jd gS t ˆ tƒrYg }ˆ jD ]}| |¡ | ˆ|ƒ¡ qH|S t ˆ tƒrŽ‡fdd„ˆ jD ƒ}ˆ jjrŒ| ‡ fdd„tˆ jƒD ƒ¡ ˆ jjrŒ| dd„ ˆˆ jƒD ƒ¡ |S t ˆ tƒr©g }ˆ jD ]}| |¡ | ˆ|ƒ¡ q˜|S g S )	Nr   rQ   rÐ   é   c                   ó   g | ]	}|  ˆ ¡r|‘qS ri   ©ÚhasrM  rO  ri   rl   r  W  ó    zAfind_substitutions.<locals>.possible_subterms.<locals>.<listcomp>c                   s8   g | ]}d |  k rt ˆ jd  ƒk rn nˆ j| ‘qS )rQ   )ÚabsrQ  r‹   )rš   rä   ©rr  ri   rl   r  Y  s    "ÿc                 S  s   g | ]}|j r|‘qS ri   )r¥   rc  ri   ri   rl   r  \  s    
ÿ)ró   r+   r!   Úinverse_trig_functionsr   r    r8   rQ  rG   rH   rI   rJ   rK   rM   rL   rN   r   rµ   Úextendr   rs  rT   r‹   Úis_Addr   )rr  Úrr«   rN  )Úpossible_subtermsrJ  rƒ  rl   rˆ  D  sL   
ÿþþþÿ







z-find_substitutions.<locals>.possible_subtermsF)rr  r   )rô   ÚdictÚfromkeysrL  r§   rµ   )rd   rJ  r£   Úresultsrq  r|  r«   rm  Únew_integrandr�   r  ri   )rd   rˆ  rJ  r£   rl   Úfind_substitutions  s$   #



€r�  c                   ó   ‡ ‡fdd„}|S )z$Strategy that rewrites an integrand.c                   sh   | \}}t d |ˆ|¡ƒ ˆ | Ž r,ˆ| Ž }||kr.t||ƒ}t|tƒs0|r2t||||ƒS d S d S d S d S )Nz/Integral: {} is rewritten with {} on symbol: {})rb   rf  Úintegral_stepsró   rï   rú   )Úintegralrd   rJ  rû   rƒ   ©r`   Úrewriteri   rl   Ú	_rewriterx  s   
ûzrewriter.<locals>._rewriterri   )r`   r’  r“  ri   r‘  rl   Úrewriterv  ó   	r”  c                   rŽ  )zAStrategy that rewrites an integrand based on some other criteria.c                   sd   | \} }|\}}t d |ˆ|| ¡ƒ | t|ƒ }ˆ |Ž r.ˆ|Ž }||kr0t|||t||ƒƒS d S d S )Nz@Integral: {} is rewritten with {} on symbol: {} and criteria: {})rb   rf  rô   rú   r�  )Úcriteriar�  rd   rJ  rQ  rû   r‘  ri   rl   Ú_proxy_rewriter…  s   ýz'proxy_rewriter.<locals>._proxy_rewriterri   )r`   r’  r—  ri   r‘  rl   Úproxy_rewriterƒ  r•  r˜  c                   ó   ‡ fdd„}|S )z4Apply the rule that matches the condition, else Nonec                   s*   ˆ   ¡ D ]\}}|| ƒr|| ƒ  S qd S rh   )r[  )r÷   Úkeyr·   ©Ú
conditionsri   rl   Úmultiplexer_rl’  s
   ÿÿz#multiplexer.<locals>.multiplexer_rlri   )rœ  r�  ri   r›  rl   Úmultiplexer�  s   rž  c                    r™  )zHStrategy that makes an AlternativeRule out of multiple possible results.c                   s´   g }d}t dƒ ˆ D ]&}|d }t d ||¡ƒ || ƒ}|r0t|tƒs0|| kr0||vr0| |¡ q
t|ƒdkr;|d S |rXdd„ |D ƒ}|rOtg | ¢|‘R Ž S tg | ¢|‘R Ž S d S )Nr   zList of Alternative RulesrQ   úRule {}: {}c                 S  s   g | ]}|  ¡ s|‘qS ri   rŸ   )rš   r·   ri   ri   rl   r  ©  s    z7alternatives.<locals>._alternatives.<locals>.<listcomp>)rb   rf  ró   rï   rµ   rÙ   rë   )r�  Úaltsrù   r·   r¨   Údoable©Úrulesri   rl   Ú_alternativesš  s&   
€ûz#alternatives.<locals>._alternativesri   )r£  r¤  ri   r¢  rl   rì   ˜  s   rì   c                 C  ó   t | Ž S rh   )r}   ©r�  ri   ri   rl   Úconstant_rule°  ó   r§  c                 C  sÊ   | \}}|  ¡ \}}||jvr)t|tƒr)t|d ƒdkr"t|||ƒS t||||ƒS ||jvrat|tƒrct||||ƒ}tt	|ƒj
ƒrC|S t	|ƒj
rMtd|ƒS t|||tt	|ƒdƒftd|ƒdfgƒS d S d S )NrQ   r   T)r¦   rx  ró   r   r[   rÈ   rŠ   rÇ   r   r    Úis_zeror}   rý   r   )r�  rd   rJ  r‹   Úexptr·   ri   ri   rl   Ú
power_rule³  s"   

þør«  c                 C  s0   | \}}t |jd tƒrt||t|jd ƒS d S rí   )ró   rQ  r   rÇ   r   ©r�  rd   rJ  ri   ri   rl   Úexp_ruleÈ  s   ÿr­  c                   s²   t ttttttttt	t
ttttti}t dtdtdi}| \}‰ |D ]6}t||ƒrV| |d¡}|j| ˆ u rVt‡ fdd„|jd |… D ƒƒsV|| |ˆ g|jd |… ¢R Ž   S q d S )Nr}  rÐ   rQ   c                 3  s   � | ]}|  ˆ ¡V  qd S rh   r  )rš   r°   rO  ri   rl   r›   ã  rP  z'orthogonal_poly_rule.<locals>.<genexpr>)rN   r   rM   r$  rG   r(  rH   r,  rI   r-  rJ   r/  rK   r0  rL   r1  ró   ÚgetrQ  r    )r�  Úorthogonal_poly_classesÚorthogonal_poly_var_indexrd   ÚklassÚ	var_indexri   rO  rl   Úorthogonal_poly_ruleÎ  s.   øý
ÿ$€ûr³  z/list[tuple[Type, Expr, Callable | None, tuple]]Ú_special_function_patternsrÒ   c                   sp  | \}}t søtdtgdd„ gd�}tdtgd�}tdtgd�}tdtgd	d„ gd�}td
tgdd„ gd�}t |||||f¡ |t | }|td  |t  | }	t  tt|dd�t d tftt|dd�t d t	ftt
|dd�t d tftt|dd�t d tftt|dd�t d tftdt|dd� d tftt|	dd�d tftt|	dd�d tftt|	dd�d tftt| t|t dd� d tftt||t dd�t d tftdt||ttdd�d   ƒ dd„ tftt||ttdd�d   ƒdd„ tff¡ | |t¡}
t D ]5\}}}}t|
|ƒ�r4|
 |¡‰ ˆ �r4t‡ fdd„tD ƒƒ}|d u �s)||Ž �r4|||g|¢R Ž   S �q d S )NrÍ   c                 S  ó   | j  S rh   ©r©  rU  ri   ri   rl   rW  ï  ó    z'special_function_rule.<locals>.<lambda>©Úexcluderw  rÎ   ©r¹  rÏ   rä   c                 S  rµ  rh   r¶  rU  ri   ri   rl   rW  ò  r·  rå   c                 S  s   | j o| j S rh   )Úis_nonnegativeÚ
is_integerrU  ri   ri   rl   rW  ô  rZ  rÐ   F©ÚevaluaterQ   c                 S  ó   | |kS rh   ri   ©rÍ   rä   ri   ri   rl   rW    r·  c                 S  r¿  rh   ri   rÀ  ri   ri   rl   rW  
  r·  c                 3  s(   � | ]}ˆ   |¡d urˆ   |¡V  qd S rh   )r®  )rš   Úw©ry  ri   rl   r›     s   € ÿÿz(special_function_rule.<locals>.<genexpr>) r´  r   Ú_symbolÚ_wildsr…  r   r   r9  r,   r4  r#   r7  r-   r;  r&   r<  r   r    r=  r>  rD  rA  rF  rP   rE  r)   rG  rI  r§   ró   ry  Útuple)r�  rd   rJ  rÍ   rÎ   rÏ   rä   rå   Úlinear_patternÚquadratic_patternÚ
_integrandÚtype_ÚpatternÚ
constraintr·   Ú	wild_valsri   rÂ  rl   Úspecial_function_ruleì  sR   ÿ ÿÿò
€ùrÍ  Úgeneric_stepÚdegenerate_stepr®   rf   c                   sl   |d u r|S t |tƒr‡ fdd„|jD ƒ}n|ˆ fg}t |tƒr&||j7 }n| |tjf¡ t|j|j|ƒS )Nc                   s    g | ]\}}||ˆ @   ¡ f‘qS ri   rZ   rÿ   ©Úgeneric_condri   rl   r    s    ÿz(_add_degenerate_step.<locals>.<listcomp>)ró   rý   rþ   rµ   r   Útruerd   re   )rÑ  rÎ  rÏ  rþ   ri   rÐ  rl   Ú_add_degenerate_step  s   

ÿ

rÓ  r�  c                   sÄ   | \}‰t dˆgd�‰t dˆdgd�‰ˆˆˆ  ‰tj‰G dd„ dtƒ‰ d‡ ‡‡‡‡‡‡fdd„‰zˆ|ƒ\}}W n
 ˆ yC   Y d S w ˆtju rLd }n	t| ˆd¡ˆƒ}t|ˆ||ƒ}tˆ||ƒS )NrÍ   rº  rÎ   r   c                   @  r¸   )z nested_pow_rule.<locals>.NoMatchNrº   ri   ri   ri   rl   ÚNoMatch/  s    rÔ  r÷   r   rf   útuple[Expr, Expr]c                   s  |   ˆ¡stjtjfS | jrG|  ¡ \}}|stjtjfS ‡fdd„|D ƒ}dd„ |D ƒ}| tj¡ t|ƒdkrE| ¡ t	dd„ |D ƒŽ fS ˆ ‚| j
rd| j| j}}|  ˆ¡rXˆ ‚ˆ|ƒ\}}||| fS |  ˆ¡}	|	r„|	ˆ |	ˆ }
}ˆ|
|  }t|dƒ‰|tjfS ˆ ‚)	Nc                   s   g | ]}ˆ |ƒ‘qS ri   ri   )rš   rr  )Ú_get_base_expri   rl   r  9  ó    z:nested_pow_rule.<locals>._get_base_exp.<locals>.<listcomp>c                 S  s   h | ]\}}|’qS ri   ri   )rš   rÎ   r  ri   ri   rl   Ú	<setcomp>:  r×  z9nested_pow_rule.<locals>._get_base_exp.<locals>.<setcomp>rQ   c                 s  s   � | ]\}}|V  qd S rh   ri   )rš   r  rå   ri   ri   rl   r›   =  rœ   z9nested_pow_rule.<locals>._get_base_exp.<locals>.<genexpr>r   )rh  r   ÚOner%  Úis_MulÚas_coeff_mulÚdiscardrÙ   Úpopr   r¥   r‹   r   ry  r   )r÷   r  r{  r‹  ÚbasesrÎ   rå   Úbase_Úsub_expry  rÍ   ©rÔ  rÖ  Úa_Úb_rÑ  rÊ  rÒ   ri   rl   rÖ  2  s2   




z&nested_pow_rule.<locals>._get_base_exp)r÷   r   rf   rÕ  )r   r   rÒ  Ú	Exceptionr}   r§   r�   rÓ  )r�  rd   r‹   r©   rÏ  rÎ  ri   rá  rl   Únested_pow_rule&  s"   ÿ
rå  Tc                   s†  | \‰ ‰ˆ   ¡ \}}tdˆgd�}tdˆgd�}tdˆdgd�}| ||ˆ  |ˆd   ¡‰ˆs3dS d‡ ‡fd
d„}‡fdd„|||fD ƒ\}}}t|dƒ}|rV|tju rYd}	n|jrdt|| ˆƒ}	ntt	||ˆ  | ˆƒƒ}	t
d| d ƒdk�r-| d|  ||d d|   }
}t|dƒ}d}|tjur®tdt|ˆ|
 d  ƒ ˆˆ|
 tjƒ}|tju rµ|S tˆ ˆ|||ƒ}t|||ƒ}|j�r'|j�r'g }t|d| d|
ft|dk|dk ƒft|d|d|
ft|dk|dkƒffD ]\}}|tju rÿ||Ž   S |tju�r| ||Ž |f¡ qð|�r%|j�s| |tjf¡ tˆ ˆ|ƒ}n|}t|||	ƒS |tjk�rAtˆ ˆ|||ƒ}t|||	ƒS dS )zm
    Set degenerate=False on recursive call where coefficient of quadratic term
    is assumed non-zero.
    rÍ   rº  rÎ   rÏ   r   rÐ   Nrf   rc   c                   sÐ   t dƒ}dt|| || ˆ| d   ƒ }t|| ƒˆ|  }dt|ƒ }	d }
|ˆur0|}
|}dt|||d   ƒ }| ||ƒ}|	dkrOt|	| ˆ|	||ƒ}|
d ur[t|ˆ||
|ƒ}|dkrftˆ ˆ||ƒ}|S )Nr«   rQ   rÐ   r   )r   r)   r€   r¢   rü   )Ú	RuleClassrÍ   Úsign_arÏ   Úsign_cÚhr£   rû   Úquadratic_baser�   r¤   Ústandard_formrƒ   ©rd   rJ  ri   rl   Úmake_inverse_trigj  s"   $
z,inverse_trig_rule.<locals>.make_inverse_trigc                   ó   g | ]	}ˆ   |tj¡‘qS ri   ©r®  r   r%  rÚ   rÂ  ri   rl   r  }  r�  z%inverse_trig_rule.<locals>.<listcomp>rQ   r!  r�   )rf   rc   )r¦   r   ry  r   r   rÒ  r©  r}   Úsqrt_linear_rulerá   r[   r�   r)   ÚNegativeOneÚfalserÌ   rÓ  Úis_realrÉ   rS   rÊ   rµ   Úis_positiverý   ÚHalfré   )r�  rØ   r‹   r   rÍ   rÎ   rÏ   rí  rÑ  rÏ  ré  ÚkÚnon_square_condÚsquare_steprÎ  rè   r£  rQ  r   ri   )rd   ry  rJ  rl   rà   [  s\   
$

(
" þ
€þrà   c                   s6   | \}‰ ‡ fdd„|  ¡ D ƒ}d |v rd S t|ˆ |ƒS )Nc                   s   g | ]}t |ˆ ƒ‘qS ri   )r�  )rš   ÚgrO  ri   rl   r  ©  s    ÿzadd_rule.<locals>.<listcomp>)Úas_ordered_termsr“   )r�  rd   r‹  ri   rO  rl   Úadd_rule§  s
   
ÿrû  c                 C  sH   | \}}|  |¡\}}|dkr t||ƒ}|d ur"t|||||ƒS d S d S rò   )rl  r�  r€   )r�  rd   rJ  rã   rT  Ú	next_stepri   ri   rl   Úmul_rule®  s   
ýrý  ú*tuple[Expr, Expr, Expr, Expr, Rule] | Nonec                   s  ‡ fdd„}ddd„}|t ƒ|tŽ ||ttƒ|tƒg}tdƒ}t| t gt¢R ƒr,||  } t|ƒD ]Ù\}}|| ƒ}|�r	|\}	}
ˆ |	jvrL|	 	|¡sL d S |	 
|d¡}	|
 
|d¡}
||krd|	 ˆ ¡sd d S t|	t ƒr|d|
 }| ˆ ¡r|t|ˆ ƒdkr| d S ||kr«|
js�|
 	t¡s�t|
tƒr«t|
ˆ ƒ}| ¡ r™ d S |	 ˆ ¡}| ¡ }|	|
|||f  S d	}|d
k r´d}n4||krÈ|
jrÈtdd„ |
jD ƒƒrÈd}n ||d d … D ]}|| ƒ}|rç|d  
|d¡ |
¡rçd} nqÐ|�r	|	 ˆ ¡}tt|
ƒˆ ƒ}| ¡ �s	| ¡ }|	|
|||f  S q0d S )Nc                   sX   |   ¡  ¡ } t| tƒs| jsg n	‡ fdd„| jD ƒ}|r*t|Ž }| |   ¡ }||fS d S )Nc                   r~  ri   )Úis_algebraic_exprrM  rO  ri   rl   r  À  r�  z;_parts_rule.<locals>.pull_out_algebraic.<locals>.<listcomp>)rg  Útogetherró   r*   rÚ  rQ  r   )rd   Ú	algebraicr«   r¬   rO  ri   rl   Úpull_out_algebraic¼  s   ÿýz'_parts_rule.<locals>.pull_out_algebraicrf   ú*Callable[[Expr], tuple[Expr, Expr] | None]c                    s   d‡ fdd„}|S )Nrd   r   rf   útuple[Expr, Expr] | Nonec                   sJ   t ‡ fdd„ˆD ƒƒr#‡fdd„ˆ jD ƒ}|r#t|Ž }ˆ | }||fS d S )Nc                 3  ó   � | ]}ˆ   |¡V  qd S rh   r  ©rš   rT  ©rd   ri   rl   r›   È  rP  zI_parts_rule.<locals>.pull_out_u.<locals>.pull_out_u_rl.<locals>.<genexpr>c                   s&   g | ]‰ t ‡ fd d„ˆD ƒƒrˆ ‘qS )c                 3  s   � | ]}t ˆ |ƒV  qd S rh   )ró   )rš   Úcls©rN  ri   rl   r›   Ê  rP  zT_parts_rule.<locals>.pull_out_u.<locals>.pull_out_u_rl.<locals>.<listcomp>.<genexpr>)r    )rš   ©Ú	functionsr	  rl   r  É  s    
ÿzJ_parts_rule.<locals>.pull_out_u.<locals>.pull_out_u_rl.<locals>.<listcomp>)r    rQ  r   )rd   rQ  r«   r¬   r
  r  rl   Úpull_out_u_rlÇ  s   z6_parts_rule.<locals>.pull_out_u.<locals>.pull_out_u_rl)rd   r   rf   r  ri   )r  r  ri   r
  rl   Ú
pull_out_uÆ  s   
z_parts_rule.<locals>.pull_out_uÚ	temporaryrQ   FrÐ   Tc                 s  s    � | ]}t |tttfƒV  qd S rh   )ró   r-   r,   r   ©rš   rÍ   ri   ri   rl   r›     s   € ÿz_parts_rule.<locals>.<genexpr>r   )rf   r  )r    r„  r-   r,   r   r   ró   rö   rx  r€  r§   Úis_polynomialrU   Úis_Derivativer+   rO   r�  rp   rR  rm   rQ  ÚallÚequalsr[   )rd   rJ  r  r  Úliate_rulesÚdummyÚindexr·   r¨   r«   r¬   Úrec_dvr­   Údur°   ÚacceptÚlruler‡  ri   rO  rl   Ú_parts_rule¹  sr   


þ

ÿ

ÿÿ€

€r  c              
     sú  | \}‰|  ¡ \}}t|ˆƒ}g }|rÅ|\}}}}}	td |||||	¡ƒ | |¡ t|tƒr1d S t|ttt	t
tfƒrR| ˆti¡}
t|
 dkrJd S t|
  d7  < tdƒD ]n}td ||||¡ƒ || |  ¡ }|dkrp nUˆ|jvr›t|ˆdd„ |D ƒdt|ƒ | ƒ}|dkr—|r—t|| ˆ|||ƒ}|  S ||   ¡ \}}t|ˆƒ}|rÄ|\}}}}}	||9 }||9 }| |||||	f¡ qV ‡ ‡fd	d
„‰ |rû|d \}}}}}	t|ˆ|||	ˆ |dd … || ƒƒ}|dkrù|rùt|| ˆ|||ƒ}|S d S )Nz,u : {}, dv : {}, v : {}, du : {}, v_step: {}rÐ   rQ   r!  z7Cyclic integration {} with v: {}, du: {}, integrand: {}c              	   S  s(   g | ]\}}}}}t d d |||d ƒ‘qS rh   )rª   )rš   r«   r¬   r°   r  r­   ri   ri   rl   r  6  s    ÿzparts_rule.<locals>.<listcomp>r�   c              
     sD   | r| d \}}}}}t |ˆ|||ˆ | dd … || ƒƒS t|ˆƒS r	  )rª   r�  )Ústepsrd   r«   r¬   r°   r  r­   ©Úmake_second_steprJ  ri   rl   r  I  s   $
z$parts_rule.<locals>.make_second_stepr   )Úas_coeff_Mulr  rb   rf  rµ   ró   rR   r-   r,   r   r&   r#   ÚxreplaceÚ_cache_dummyÚ_parts_u_cacherß   rg  rx  r²   rÙ   r€   rª   )r�  rd   r�   r¨   r  r«   r¬   r°   r  r­   Úcachekeyr  r´   r·   Únext_constantÚnext_integrandri   r  rl   Ú
parts_rule  s\   



ÿý
$ûr&  c                 C  sD  | \}}|t |ƒkrt||ƒS |t|ƒkrt||ƒS |t|ƒd kr't||ƒS |t|ƒd kr4t||ƒS t|t	ƒrDt |j
Ž t|j
Ž  }nTt|tƒrTt|j
Ž t |j
Ž  }nDt|tƒru|j
d }t|ƒd t	|ƒt|ƒ  t|ƒt	|ƒ  }n#t|tƒr–|j
d }t|ƒd t|ƒt|ƒ  t|ƒt|ƒ  }nd S t|||t||ƒƒS ©NrÐ   r   )r-   r¼   r,   r¾   r1   rÂ   r0   rÃ   ró   r.   rQ  r/   rú   r�  )r�  rd   rJ  rû   rN  ri   ri   rl   Ú	trig_ruleW  s2   







ÿ

ÿr(  c                 C  sH   | \}}|t |ƒt|ƒ krt||ƒS |t|ƒt|ƒ kr"t||ƒS d S rh   )r1   r.   rÀ   r0   r/   rÁ   r¬  ri   ri   rl   Útrig_product_rules  s   

ÿr)  c           "      C  sÈ  | \}}t d|gd�}t d|gd�}t d|gd�}| |||d  |  ¡}|rè|| || || }}}t|||||ƒ}|jrÂ|jrÂ|| dk}|tju rQ|S |dt| ƒ t|ƒ  }	t| | ƒ}
d||
  }d||
  }t||||
 ƒt| |d|t||||
 ƒƒg}||  }}t	|||ƒ}|	dkr§t
|	|d	d
�}t|||	||ƒ}t||||ƒ}|tju rµ|S t||||f|tjfgƒS t|||dƒ}|dkrÙt||d| |d |ƒ}t|||t|dƒf|dfgƒS t d|gd�}| |||d  ||  |  ¡}|�r<|| || }}|j�rd S tdƒ}||d|   }| |||d|   ¡}t||ƒ}|�r:t|||||ƒS d S t d|gd�}| || | ||d  ||  |  ¡}|�râ|| || || || || f\}}}}}|j�rwd S ||d  ||  | }|d|  }d| | | }| | | }tdƒ}t||||t|d |ƒƒ}|dk�r¼t|| | |||| |ƒ}|j�rÂ|S t|| |ƒ}t	||||gƒ} || | ||  }!t|||!| ƒS d S )NrÍ   rº  rÎ   rÏ   rÐ   r   rQ   r�   Fr½  rÖ   Trä   r«   rå   )r   ry  r  r?  r   rÒ  r)   rÈ   r€   r“   r   rú   rò  rý   rŠ   r   r©  r   r§   r�  r¢   )"r�  rd   rJ  rÍ   rÎ   rÏ   ry  Úgeneral_ruleÚpositive_condrã   r�   Úr1Úr2Ú	log_stepsrû   ÚsubÚnegative_stepÚpowerrä   Úmatch2r«   r¤   Ú
integrand2rü  rå   Úmatch3ÚdenominatorÚconstÚnumer1Únumer2Ústep1Ústep2r•   Úrewritenri   ri   rl   Úquadratic_denom_rule{  sŒ   
ÿ
"
*,ÿ

ÿr<  c                   sø  | \}}t d|gd�}t d|dgd�}d }‰ g g g }}}| t¡D ]_}	|	j|	j}
}|js5||
jvr6q$|js< dS |
 |||  ¡}|sHq$|| || }}|| |ˆ  ks^ˆ | j	sa dS ˆ dksnˆ | dkt
ju rs||}‰ | |
¡ | |¡ | |j¡ q$ˆ dkrŠdS t|ƒ‰|ˆ |  dˆ  }tdƒ‰| ‡ ‡‡fdd	„t|||ƒD ƒ¡ |ˆˆ | ˆ  ¡}t|ˆˆd   ˆ ˆ  ˆƒ}| ¡ sút||ˆ||ƒ}tˆ dƒ}|t
jurø| t |d¡¡}t||ƒ}t||||f|t
jfgƒ}|S dS )
z*
    Substitute common (a+b*x)**(1/n)
    rÍ   rº  rÎ   r   NrQ   r«   c                   s<   i | ]\}}}|t j|  |ˆ  t j|  ˆˆ|   “qS ri   )r   rÙ  )rš   r‹   rÎ   Úq©Úb0Úq0r«   ri   rl   Ú
<dictcomp>ç  s    .ÿz$sqrt_linear_rule.<locals>.<dictcomp>)r   r  r   r‹   r   rs  rx  Úis_Rationalry  r»  r   rÒ  rµ   r=  rV   r   r§   Úzipr�  rp   r¢   r   r‰  rŠ  rý   )r�  rd   rÒ   rÍ   rÎ   Úa0rÞ  ÚqsÚbsÚpow_r‹   r©   ry  Úa1Úb1Úu_xrn  rƒ   rè   rÑ  Ú
simplifiedrÏ  ri   r>  rl   rð  È  sT   



ÿÿ


ùrð  c                   sÆ  | \}‰t dˆgd�‰ t dˆgd�‰t dˆdgd�‰t dƒ}t ddd	„ gd
�}| |tˆ ˆˆ  ˆˆd   ƒ|  ¡}|s@d S |ˆ  |ˆ |ˆ || || f\‰ ‰‰}}| ˆ¡}|d u rad S tˆdƒ}|rm|tju rpd }n ˆjrt|tˆ ƒ|  ˆƒ}nt	t
|tˆ ˆˆ  ƒ|  ˆƒƒ}d‡ ‡‡‡fdd„}	|dkrÑ|ˆ ˆˆ  ˆˆd   |d d   }
|
 ¡ tˆ ˆˆ  ˆˆd   ƒ }|	|
|ƒ}t|ˆ||ƒ}n|dkrÛ|	||ƒ}nd S t|||ƒS )NrÍ   rº  rÎ   rÏ   r   rT  râ   c                 S  s   | j o| jS rh   )rs  Úis_oddrt  ri   ri   rl   rW  ú  ó    z%sqrt_quadratic_rule.<locals>.<lambda>rv  rÐ   Ú
numer_polyrX   rd   r   c              	     s�  t ˆ ˆˆ  ˆˆd   ƒ}|  ¡ }|dkr¹|dkr|  ¡ ntj|  ¡ f\}}|dˆ  }||ˆ  }dˆ ˆ ˆ | }d }	d }
|dkrvtdƒ}tdt |ƒ ||tj ƒ}t	|ˆ|ˆ ˆˆ  ˆˆd   |ƒ}
|dkrvt
|| ˆ|||
ƒ}
|dkr•ttd| ˆƒdd�}	|dkr•t
|| ˆ|d| |	ƒ}	|
r³|	r³t|| || dd�}t|ˆ|t|ˆ|
|	gƒƒ}|S |
p¶|	}|S |  ¡ }t|ˆˆ ˆˆ|ƒ}|S )NrÐ   rQ   r   r«   Fr×   r½  )r)   rU   Ú
all_coeffsr   r%  Úas_exprr   rŠ   rõ  r¢   r€   rà   rá   r   rú   r“   rÔ   )rN  rd   r  Údegrå   rä   ÚAÚBÚpre_substituteÚconstant_stepÚlinear_stepr«   Úpow_ruleÚaddrè   rÕ   ©rÍ   rÎ   rÏ   rÒ   ri   rl   Úsqrt_quadratic_denom_rule  s8   "$üþz6sqrt_quadratic_rule.<locals>.sqrt_quadratic_denom_rulerQ   r�   )rN  rX   rd   r   )r   ry  r)   Úas_polyr   r   rÒ  r©  r�  rð  rá   rP  rú   rÓ  )r�  rØ   rd   rT  râ   ry  Úf_polyrÑ  rÏ  rZ  rN  rû   rƒ   rÎ  ri   rY  rl   rê   ô  s:   *,

" ($
rê   útuple[Expr, Symbol]c                 C  sr  | \}}t |tƒr³|jd |krµ|jtkrt||ƒS |jtkr$t||ƒS tdƒ}|jt	krJt|ƒt|ƒ }t
|||t|||t|ƒtd| ||ƒƒƒS |jtkrlt|ƒt|ƒ }t
|||t|||t|ƒtd| ||ƒƒƒS | t	¡}|jtkr—t
|||t|||t	|d ƒtd|d d  |tdƒtjtjƒƒƒS |jtkr·t
|||t|||t	|d ƒtd| ||ƒƒƒS d S d S d S )Nr   r«   rQ   rÐ   )ró   r!   rQ  r  r&   rÅ   r#   rÆ   r   r'   rú   r¢   rÈ   r$   r’  r%   r  r   rÙ  r"   )r�  rd   rJ  r«   rû   ri   ri   rl   Úhyperbolic_rule7  s@   




ÿ
ÿ

"ÿÿ
ÿÿër^  c                 C  sT   t d| gd�}t d| gd�}t d| gdd„ gd�}t d| gd	d„ gd�}||||fS )
NrÍ   rº  rÎ   r‘   c                 S  ó
   t | tƒS rh   ©ró   r   rt  ri   ri   rl   rW  V  ó   
 zmake_wilds.<locals>.<lambda>r¸  râ   c                 S  r_  rh   r`  rt  ri   ri   rl   rW  W  ra  )r   )rJ  rÍ   rÎ   r‘   râ   ri   ri   rl   Ú
make_wildsR  s
   rb  c                 C  ó>   t | ƒ\}}}}t||  ƒ| t||  ƒ|  }|||||fS rh   )rb  r-   r,   ©rJ  rÍ   rÎ   r‘   râ   rÊ  ri   ri   rl   Úsincos_pattern[  ó    re  c                 C  rc  rh   )rb  r.   r1   rd  ri   ri   rl   Útansec_patternb  rf  rg  c                 C  rc  rh   )rb  r/   r0   rd  ri   ri   rl   Úcotcsc_patterni  rf  rh  c                 C  sD   t d| gd�}t d| gd�}t dƒ}t||  | ƒ| }||||fS )Nr‘   rº  rÎ   rù  )r   r8   )rJ  r‘   rÎ   rù  rÊ  ri   ri   rl   Úheaviside_patternp  s
   ri  c                   r™  )Nc                   s   ˆ | Ž S rh   ri   ©rQ  ©r  ri   rl   Ú
uncurry_rlz  r¨  zuncurry.<locals>.uncurry_rlri   )r  rl  ri   rk  rl   Úuncurryy  s   rm  c                   r™  )Nc                   sB   | \}}}}}}ˆ ||||||ƒ}||krt |||t||ƒƒS d S rh   )rú   r�  )rQ  rÍ   rÎ   r‘   râ   rd   rJ  rû   ©r’  ri   rl   Útrig_rewriter_rl  s
   ÿz'trig_rewriter.<locals>.trig_rewriter_rlri   )r’  ro  ri   rn  rl   Útrig_rewriter~  s   rp  c                 C  s   |j o|j o|jo|jS rh   )Úis_evenr»  ©rÍ   rÎ   r‘   râ   rÛ   ræ   ri   ri   rl   rW  ‡  s    ÿrW  c                 C  s@   dt d|  | ƒ d |d  dt d| | ƒ d |d   S r.  )r,   ©rÍ   rÎ   r‘   râ   rÛ   rJ  ri   ri   rl   rW  ‹  s    ÿc                 C  s   |j o|dkS ©Nr}  ©rL  rr  ri   ri   rl   rW  Ž  rZ  c                 C  s<   dt | | ƒd  |d d  t| | ƒ t || ƒ|  S r.  )r,   r-   rs  ri   ri   rl   rW  ‘  ó
    
ÿþc                 C  ó   |j o|dkS rt  ru  rr  ri   ri   rl   rW  •  rZ  c                 C  s<   dt || ƒd  |d d  t|| ƒ t | | ƒ|  S r.  )r-   r,   rs  ri   ri   rl   rW  ˜  rv  c                 C  rw  ©Nr!  ©rq  rr  ri   ri   rl   rW  œ  rZ  c                 C  ó@   dt || ƒd  |d d  t|| ƒd  t | | ƒ|  S r.  )r.   r1   rs  ri   ri   rl   rW  ž  ó
    ÿþc                 C  ó   |j S rh   ru  rr  ri   ri   rl   rW  ¢  ru  c                 C  ó<   t | | ƒd d |d d  t| | ƒ t || ƒ|  S ©NrÐ   rQ   )r1   r.   rs  ri   ri   rl   rW  ¤  rv  c                 C  s   |dko|dkS r'  ri   rr  ri   ri   rl   rW  ¨  rX  c                 C  s   t | | ƒd d S r~  )r1   rs  ri   ri   rl   rW  ª  r×  c                 C  rw  rx  ry  rr  ri   ri   rl   rW  ¬  rZ  c                 C  rz  r.  )r/   r0   rs  ri   ri   rl   rW  ®  r{  c                 C  r|  rh   ru  rr  ri   ri   rl   rW  ²  ru  c                 C  r}  r~  )r0   r/   rs  ri   ri   rl   rW  ´  rv  c                   s„   | \‰ }t ‡ fdd„ttfD ƒƒr@t|ƒ\}}}}}ˆ  |¡‰ˆs#d S ttttt	t
tiƒt‡fdd„||||fD ƒˆ |g ƒƒS d S )Nc                 3  r  rh   r  r  r  ri   rl   r›   »  rP  z#trig_sincos_rule.<locals>.<genexpr>c                   rî  ri   rï  rÚ   rÂ  ri   rl   r  Æ  r�  z$trig_sincos_rule.<locals>.<listcomp>)r    r-   r,   re  ry  rž  Úsincos_botheven_conditionÚsincos_bothevenÚsincos_sinodd_conditionÚsincos_sinoddÚsincos_cosodd_conditionÚsincos_cosoddrÅ  ©r�  rJ  rÊ  rÍ   rÎ   r‘   râ   ri   ©rd   ry  rl   Útrig_sincos_rule¸  s$   
ýÿÿüúr‡  c                   sž   | \‰ }ˆ   dt|ƒ t|ƒi¡‰ t‡ fdd„ttfD ƒƒrMt|ƒ\}}}}}ˆ  |¡‰ˆs0d S ttt	t
tttiƒt‡fdd„||||fD ƒˆ |g ƒƒS d S )NrQ   c                 3  r  rh   r  r  r  ri   rl   r›   Ð  rP  z#trig_tansec_rule.<locals>.<genexpr>c                   rî  ri   rï  rÚ   rÂ  ri   rl   r  Û  r�  z$trig_tansec_rule.<locals>.<listcomp>)r§   r,   r1   r    r.   rg  ry  rž  Útansec_tanodd_conditionÚtansec_tanoddÚtansec_seceven_conditionÚtansec_secevenÚtan_tansquared_conditionÚtan_tansquaredrÅ  r…  ri   r†  rl   Útrig_tansec_ruleÉ  s*   ÿ
ýÿÿüúrŽ  c              	     s¾   | \‰ }ˆ   dt|ƒ t|ƒdt|ƒ t|ƒt|ƒt|ƒ t|ƒi¡‰ t‡ fdd„ttfD ƒƒr]t|ƒ\}}}}}ˆ  |¡‰ˆsBd S t	t
tttiƒt‡fdd„||||fD ƒˆ |g ƒƒS d S )NrQ   c                 3  r  rh   r  r  r  ri   rl   r›   æ  rP  z#trig_cotcsc_rule.<locals>.<genexpr>c                   rî  ri   rï  rÚ   rÂ  ri   rl   r  ð  r�  z$trig_cotcsc_rule.<locals>.<listcomp>)r§   r-   r0   r.   r/   r,   r    rh  ry  rž  Úcotcsc_cotodd_conditionÚcotcsc_cotoddÚcotcsc_csceven_conditionÚcotcsc_cscevenrÅ  r…  ri   r†  rl   Útrig_cotcsc_ruleÞ  s,   ý
þÿÿýúr“  c                 C  sj   | \}}t dtd| ƒgd�}| td| ƒ| ¡}|r3dt|ƒ t|ƒ td| ƒ }t|| |ƒS d S )NrÍ   rÐ   rº  )r   r-   ry  r,   r�  )r�  rd   rJ  rÍ   ry  Ú
sin_doubleri   ri   rl   Útrig_sindouble_ruleó  s    þr•  c                 C  s"   t ttƒttƒttƒttƒƒ| ƒS rh   )r^   r_   r‡  rŽ  r“  r•  r¦  ri   ri   rl   Útrig_powers_products_ruleû  s   ýýr–  c              	   C  s^  | \}}t dd|gd�}t dd|gd�}tdƒ}|||d   }| |¡}|D �]}| |¡}	|	 |tj¡}
|	 |tj¡}|
jrD|
dkpF|
j}|jrN|dkpP|j}|
jrX|
dk pZ|
j	}|jrb|dk pd|j	}d }|rz|rzt
|
ƒt
|ƒ t|ƒ }d}n;|r˜|r˜t
|
ƒt
| ƒ }|t|ƒ }t|| k||k ƒ}n|rµ|rµt
|
 ƒt
|ƒ }|t|ƒ }t|| k||k ƒ}|�r,i }ttttttfD ]}||ƒ|t
||ƒd ƒ< d||ƒ |t
||ƒd	 ƒ< qÂ| ||¡ ¡ }t||ƒ}| |¡�s,|t||ƒ9 }| ¡ }| dt|ƒ ¡}|�r| dt|ƒ t|ƒi¡}t||ƒ}| ¡ �s,t|||||||ƒ  S q'd S )
NrÍ   r   rº  rÎ   r  rÐ   TrQ   rÖ   )r   r   r  ry  r®  r   r%  Ú	is_numberrô  Úis_negativer)   r.   r-   rS   r1   r,   r0   r/   r§   r  ra  r€  rL  r   r�  rp   r  )r�  rd   rJ  rR  rS  r  Útarget_patternÚmatchesr÷   ry  rÍ   rÎ   Ú
a_positiveÚ
b_positiveÚ
a_negativeÚ
b_negativeÚx_funcr  r�   ÚsubstitutionsrT  ÚreplacedÚsecantsrƒ   ri   ri   rl   Útrig_substitution_rule  sd   


ÿ
ÿ


ÿ€Ïr£  c           	      C  sx   | \}}t |ƒ\}}}}| |¡}|r8d|| kr:t|| |ƒ}|| || }}t|||| | | | |ƒS d S d S rí   )ri  ry  r�  r  )	r�  rd   rJ  rÊ  r‘   rÎ   rù  ry  rƒ   ri   ri   rl   Úheaviside_rule=  s   
ür¤  c           
      C  sÒ   | \}}t |jƒdkrtj}n|jd }|jr|dk rd S td|gd�td|dgd�}}|jd  |||  ¡}|s=d S || || }}t|dƒ}|tju rSd }nt	t
||ƒ|ƒ}t|||||ƒ}	t||	|ƒS )NrQ   r   rÍ   rº  rÎ   )rÙ   rQ  r   r%  rs  r   ry  r   rÒ  r}   r9   r  rÓ  )
r�  rd   rÒ   râ   rÍ   rÎ   ry  rÑ  rÏ  rÎ  ri   ri   rl   Údirac_delta_ruleH  s"   
 

r¥  c              	   C  sd  | \}}t dƒ}t|||ƒ}d}|r®tdƒ g }|D ]�\}}}	t|	|ƒ}
|d }td ||
¡ƒ |
 ¡ r5qt|d ƒdkr�| ¡ \}}|
rOt||	 |||	|
ƒ}
|j	r�g }g }t
|tƒr_|j}n| |¡ |D ]}t|jƒs‚tt||dƒ|ƒ}|r‚| |t|dƒf¡ qf| |
df¡ t|	||ƒ}
| t|||||
ƒ¡ qt|ƒdkr¨t|||ƒS |r°|d S d S d S )Nr«   r   zList of Substitution RulesrQ   rŸ  T)r   r�  rb   r�  rf  rp   r[   rk  r€   rx  ró   r   rQ  rµ   r   r©  ra  r   rý   r¢   rÙ   rë   )r�  rd   rJ  r£   r   rù   Úwaysr¤   rÏ   rn  Úsubruler  r  Ú	piecewiseÚcould_be_zeror÷   rƒ   ri   ri   rl   Úsubstitution_rule^  sR   



þ€Ö)rª  c                 C  ó   |   ¡ S rh   )ri  rì  ri   ri   rl   rW  ’  r·  c                 C  s
   |   |¡S rh   )Úapartrì  ri   ri   rl   rW  “  ra  c                 C  ry   rð   ri   rì  ri   ri   rl   rW  ˜  s    c                 C  r«  rh   )rg  rì  ri   ri   rl   rW  ™  r·  c                   s&   t | ttfƒpt‡ fdd„| jD ƒƒS )Nc                 3  s    � | ]}|j p| ˆ ¡V  qd S rh   )r¥   r  rM  rO  ri   rl   r›   �  s   € z<lambda>.<locals>.<genexpr>)ró   r   r   r  rQ  rì  ri   rO  rl   rW  œ  s   &c                 C  r«  rh   ©Úexpandrì  ri   ri   rl   rW  ž  r·  c                 C  s   t dd„ |  t¡D ƒƒdkS )Nc                 S  s   h | ]}|j d  ’qS )r   rj  r  ri   ri   rl   rØ  £  s    z<lambda>.<locals>.<setcomp>rQ   )rÙ   Úatomsr+   rì  ri   ri   rl   rW  ¢  r2  c                 C  s   | j dd�S )NT)Útrigr­  rì  ri   ri   rl   rW  ¤  rM  c                 C  sJ   | d }|j }|j}|j}| j|v r!| j|v rt| Ž S t|| jƒS t| Ž S rí   )Ú	variablesr÷   rx  rJ  rñ   rï   r}   )r�  rd   Údiff_variablesÚundifferentiated_functionÚintegrand_variablesri   ri   rl   Úderivative_rule¦  s   

rµ  c                 C  sJ   | \}}|  dt|ƒ ¡r#| dt|ƒ t|ƒ¡}t|||t||ƒƒS d S rò   )ry  r,   r§   r1   rú   r�  )r�  rd   rJ  rû   ri   ri   rl   Úrewrites_rule´  s
   þr¶  c                 C  r¥  rh   )rï   r¦  ri   ri   rl   Úfallback_rule»  r¨  r·  zdict[Expr, Expr | None]Ú_integral_cachezdict[Expr, int]r"  Úzc                   sv  |   ˆti¡}|tv r t| du rt| ˆƒS t|   tˆ¡ˆfS dt|< t| ˆƒ}‡fdd„‰ ‡ fdd„}tttƒttˆ t	ttt
ƒttƒttƒttƒƒtt
ttttttttƒttƒttƒttƒttƒttƒƒtttttttttt t!t"iƒƒtttƒtt#ƒtt$t%t&t'|tt	ƒt(ƒt'|tt	ƒt)ƒt'|tt*gt+¢R Ž t,ƒt'|tt	ƒt-ƒt.t/ƒƒtt'|tt	ƒt0ƒƒtt1ƒƒt2ƒ|ƒ}t|= |S )a‹  Returns 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(integrand=exp(x)/(exp(2*x) + 1), variable=x, u_var=_u, u_func=exp(x),
    substep=ArctanRule(integrand=1/(_u**2 + 1), variable=_u, a=1, b=1, c=1))
    >>> print(repr(integral_steps(sin(x), x)))     # doctest: +NORMALIZE_WHITESPACE
    SinRule(integrand=sin(x), variable=x)
    >>> print(repr(integral_steps((x**2 + 3)**2, x)))     # doctest: +NORMALIZE_WHITESPACE
    RewriteRule(integrand=(x**2 + 3)**2, variable=x, rewritten=x**4 + 6*x**2 + 9,
    substep=AddRule(integrand=x**4 + 6*x**2 + 9, variable=x,
    substeps=[PowerRule(integrand=x**4, variable=x, base=x, exp=4),
    ConstantTimesRule(integrand=6*x**2, variable=x, constant=6, other=x**2,
    substep=PowerRule(integrand=x**2, variable=x, base=x, exp=2)),
    ConstantRule(integrand=9, variable=x)]))

    Returns
    =======

    rule : Rule
        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 }ˆ |jvr
tS tttfD ]}t||ƒr|  S qt|ƒS rh   )rd   rx  r   r   r+   rO   ró   Útype)r�  rd   r  rO  ri   rl   rš    s   

ÿzintegral_steps.<locals>.keyc                    s   ‡‡ fdd„}|S )Nc                   s   ˆ | ƒ}|o
t |ˆƒS rh   )Ú
issubclass)r�  rö  )rš  Úklassesri   rl   Ú_integral_is_subclass  s   zKintegral_steps.<locals>.integral_is_subclass.<locals>._integral_is_subclassri   )r¼  r½  )rš  )r¼  rl   Úintegral_is_subclass  s   z,integral_steps.<locals>.integral_is_subclass)3r   r!  r¸  rï   rá   r^   r_   rÍ  r]   r   r«  rà   rð  r<  r   r   r­  r   rû  r   rý  r)  r¤  rê   r   rµ  r+   r(  r8   r9   r¥  rO   r³  r   r§  r^  rì   r¶  rª  r`   Úpartial_fractions_ruleÚcancel_ruler    r„  r&  Údistribute_expand_ruler–  Útrig_expand_rulerå  r£  r·  )rd   rJ  Úoptionsr#  r�  r¾  r¨   ri   )rš  rJ  rl   r�  Å  sŠ   -
ÿ

þýðþþÿýþïéÓ-Ó.r�  c                 C  sŠ   t | |ƒ ¡ }t ¡  t|tƒrCt|jƒdkrC|jd d }t|tƒrC|jd d dkrC| 	|jd d t
|jŽ f|jd d df¡}|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
    rÐ   r   rQ   T)r�  rm   r"  Úclearró   r*   rÙ   rQ  r   r  r   )rT  rø   r¨   r   ri   ri   rl   ÚmanualintegrateC  s   1þrÅ  N)rÎ  rc   rÏ  r®   rf   rc   )r�  rá   )T)rf   rþ  )r�  r]  (  r{   Ú
__future__r   Útypingr   r   r   r   Úabcr   r   Údataclassesr	   Úcollectionsr
   Úcollections.abcr   Úsympy.core.addr   Úsympy.core.cacher   Úsympy.core.containersr   Úsympy.core.exprr   Úsympy.core.functionr   Úsympy.core.logicr   Úsympy.core.mulr   Úsympy.core.numbersr   r   r   Úsympy.core.powerr   Úsympy.core.relationalr   r   r   Úsympy.core.singletonr   Úsympy.core.symbolr   r   r   Ú$sympy.functions.elementary.complexesr   Ú&sympy.functions.elementary.exponentialr   r    Ú%sympy.functions.elementary.hyperbolicr!   r"   r#   r$   r%   r&   r'   r(   Ú(sympy.functions.elementary.miscellaneousr)   Ú$sympy.functions.elementary.piecewiser*   Ú(sympy.functions.elementary.trigonometricr+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   Ú'sympy.functions.special.delta_functionsr8   r9   Ú'sympy.functions.special.error_functionsr:   r;   r<   r=   r>   r?   r@   rA   rB   rC   Ú'sympy.functions.special.gamma_functionsrD   Ú*sympy.functions.special.elliptic_integralsrE   rF   Ú#sympy.functions.special.polynomialsrG   rH   rI   rJ   rK   rL   rM   rN   rO   Ú&sympy.functions.special.zeta_functionsrP   Ú	integralsrR   Úsympy.logic.boolalgrS   Úsympy.ntheory.factor_rT   Úsympy.polys.polytoolsrU   rV   rW   rX   Úsympy.simplify.radsimprY   Úsympy.simplify.simplifyr[   Úsympy.solvers.solversr\   Úsympy.strategies.corer]   r^   r_   r`   Úsympy.utilities.iterablesra   Úsympy.utilities.miscrb   rc   rx   r}   r€   rŠ   r�   r“   r¢   rª   r²   r¹   r¼   r¾   rÀ   rÁ   rÂ   rÃ   rÄ   rÅ   rÆ   rÇ   rÈ   rÉ   rÊ   rÌ   rÔ   ré   rë   rï   rñ   rú   rü   rý   r  r  r  r  r  r   r$  r(  r,  r-  r/  r0  r1  r3  r4  r7  r9  r;  r<  r=  r>  rA  rD  rE  rF  rG  rI  rá   rL  ra  r„  r�  r”  r˜  rž  rì   r§  r«  r­  r³  r´  rv   rÄ  rÃ  rÍ  rÓ  rå  rà   rû  rý  r  r&  r(  r)  r<  rð  rê   r^  rb  re  rg  rh  ri  rm  rp  r  r€  r�  r‚  rƒ  r„  rŠ  r‹  rˆ  r‰  rŒ  r�  r‘  r’  r�  r�  r‡  rŽ  r“  r•  r–  r£  r¤  r¥  rª  r¿  rÀ  rÁ  rÂ  rµ  r¶  r·  r¸  Úintr"  r!  r�  rÅ  ri   ri   ri   rl   Ú<module>   s   (<0,	#	2		!W+5L_?M,C




ÿÿÿÿÿÿÿÿÿ<3þüýü~