U
    ZÊ¹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,dÁœdÂdÃ„ZÖd¤dÄœdÅdÆ„Z×�d*d¤dÄœdÈdÉ„ZØdÊdË„ ZÙd¤dÄœdÌdÍ„ZÚdÎdÏœdÐdÑ„ZÛdÒdÓ„ ZÜdÔdÕ„ ZÝd¤dÄœdÖd×„ZÞdØdÙ„ Zßd¤dÄœdÚdÛ„Zà�d+d¤dÄœdÜdÝ„ZádÞ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�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 (,  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                   @  sB   e Zd ZU ded< ded< eddœdd„ƒZeddœd	d
„ƒZdS )ÚRuler   Ú	integrandr   Úvariable©Úreturnc                 C  s   d S ©N© ©Úselfri   ri   ú^/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/integrals/manualintegrate.pyÚevalM   s    z	Rule.evalÚboolc                 C  s   d S rh   ri   rj   ri   ri   rl   Úcontains_dont_knowQ   s    zRule.contains_dont_knowN)Ú__name__Ú
__module__Ú__qualname__Ú__annotations__r   rm   ro   ri   ri   ri   rl   rc   H   s   
rc   c                   @  s   e Zd ZdZddœdd„ZdS )Ú
AtomicRulez1A simple rule that does not depend on other rulesrn   rf   c                 C  s   dS )NFri   rj   ri   ri   rl   ro   Y   s    zAtomicRule.contains_dont_knowN)rp   rq   rr   Ú__doc__ro   ri   ri   ri   rl   rt   V   s   rt   c                   @  s   e Zd ZdZddœdd„ZdS )ÚConstantRulezintegrate(a, x)  ->  a*xr   rf   c                 C  s   | j | j S rh   )rd   re   rj   ri   ri   rl   rm   `   s    zConstantRule.evalN©rp   rq   rr   ru   rm   ri   ri   ri   rl   rv   ]   s   rv   c                   @  sF   e Zd ZU dZded< ded< ded< ddœdd	„Zd
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   )ry   r{   rm   rj   ri   ri   rl   rm   k   s    zConstantTimesRule.evalrn   c                 C  s
   | j  ¡ S rh   ©r{   ro   rj   ri   ri   rl   ro   n   s    z$ConstantTimesRule.contains_dont_knowN©rp   rq   rr   ru   rs   rm   ro   ri   ri   ri   rl   rx   d   s   
rx   c                   @  s0   e Zd ZU dZded< ded< 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.evalN©rp   rq   rr   ru   rs   rm   ri   ri   ri   rl   r~   r   s   
r~   c                   @  s0   e Zd ZU dZded< ded< ddœdd„ZdS )	Ú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.evalNr‚   ri   ri   ri   rl   rƒ      s   
rƒ   c                   @  s6   e Zd ZU dZded< ddœdd„Zddœd	d
„ZdS )ÚAddRulezDintegrate(f(x) + g(x), x) -> integrate(f(x), x) + integrate(g(x), x)ú
list[Rule]Úsubstepsr   rf   c                 C  s   t dd„ | jD ƒŽ S )Nc                 s  s   | ]}|  ¡ V  qd S rh   ©rm   ©Ú.0r{   ri   ri   rl   Ú	<genexpr>‘   s     zAddRule.eval.<locals>.<genexpr>)r   r‡   rj   ri   ri   rl   rm   �   s    zAddRule.evalrn   c                 C  s   t dd„ | jD ƒƒS )Nc                 s  s   | ]}|  ¡ V  qd S rh   ©ro   r‰   ri   ri   rl   r‹   ”   s     z-AddRule.contains_dont_know.<locals>.<genexpr>)Úanyr‡   rj   ri   ri   rl   ro   “   s    zAddRule.contains_dont_knowNr}   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dœd	d
„Zd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.evalrn   c                 C  s
   | j  ¡ S rh   r|   rj   ri   ri   rl   ro   §   s    zURule.contains_dont_knowNr}   ri   ri   ri   rl   rŽ   —   s   
	rŽ   c                   @  sN   e Zd ZU dZded< ded< ded< ded	< dd
œdd„Zd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 k	st‚| j ¡ }| j| | j  ¡  S rh   )r›   ÚAssertionErrorr™   rm   r—   )rk   Úvri   ri   rl   rm   ³   s    
zPartsRule.evalrn   c                 C  s   | j  ¡ p| jd k	o| j ¡ S rh   )r™   ro   r›   rj   ri   ri   rl   ro   ¸   s    
ÿzPartsRule.contains_dont_knowNr}   ri   ri   ri   rl   r–   «   s   
r–   c                   @  s>   e Zd ZU dZded< ded< ddœdd„Zd	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.evalrn   c                 C  s   t dd„ | jD ƒƒS )Nc                 s  s   | ]}|  ¡ V  qd S rh   rŒ   r‰   ri   ri   rl   r‹   Ì   s     z5CyclicPartsRule.contains_dont_know.<locals>.<genexpr>)r�   rŸ   rj   ri   ri   rl   ro   Ë   s    z"CyclicPartsRule.contains_dont_knowNr}   ri   ri   ri   rl   rž   ½   s
   
rž   c                   @  s   e Zd ZdS )ÚTrigRuleN©rp   rq   rr   ri   ri   ri   rl   r¤   Ï   s   r¤   c                   @  s   e Zd ZdZddœdd„ZdS )ÚSinRulezintegrate(sin(x), x) -> -cos(x)r   rf   c                 C  s   t | jƒ S rh   )r,   re   rj   ri   ri   rl   rm   ×   s    zSinRule.evalNrw   ri   ri   ri   rl   r¦   Ô   s   r¦   c                   @  s   e Zd ZdZddœdd„ZdS )ÚCosRulezintegrate(cos(x), x) -> sin(x)r   rf   c                 C  s
   t | jƒS rh   )r-   re   rj   ri   ri   rl   rm   Þ   s    zCosRule.evalNrw   ri   ri   ri   rl   r§   Û   s   r§   c                   @  s   e Zd ZdZddœdd„ZdS )Ú
SecTanRulez%integrate(sec(x)*tan(x), x) -> sec(x)r   rf   c                 C  s
   t | jƒS rh   )r1   re   rj   ri   ri   rl   rm   å   s    zSecTanRule.evalNrw   ri   ri   ri   rl   r¨   â   s   r¨   c                   @  s   e Zd ZdZddœdd„ZdS )Ú
CscCotRulez&integrate(csc(x)*cot(x), x) -> -csc(x)r   rf   c                 C  s   t | jƒ S rh   )r0   re   rj   ri   ri   rl   rm   ì   s    zCscCotRule.evalNrw   ri   ri   ri   rl   r©   é   s   r©   c                   @  s   e Zd ZdZddœdd„ZdS )ÚSec2Rulez!integrate(sec(x)**2, x) -> tan(x)r   rf   c                 C  s
   t | jƒS rh   )r.   re   rj   ri   ri   rl   rm   ó   s    zSec2Rule.evalNrw   ri   ri   ri   rl   rª   ð   s   rª   c                   @  s   e Zd ZdZddœdd„ZdS )ÚCsc2Rulez"integrate(csc(x)**2, x) -> -cot(x)r   rf   c                 C  s   t | jƒ S rh   )r/   re   rj   ri   ri   rl   rm   ú   s    zCsc2Rule.evalNrw   ri   ri   ri   rl   r«   ÷   s   r«   c                   @  s   e Zd ZdS )ÚHyperbolicRuleNr¥   ri   ri   ri   rl   r¬   þ   s   r¬   c                   @  s   e Zd ZdZddœdd„ZdS )ÚSinhRulez integrate(sinh(x), x) -> cosh(x)r   rf   c                 C  s
   t | jƒS rh   )r#   re   rj   ri   ri   rl   rm     s    zSinhRule.evalNrw   ri   ri   ri   rl   r­     s   r­   c                   @  s   e Zd ZdZdd„ ZdS )ÚCoshRulez integrate(cosh(x), x) -> sinh(x)c                 C  s
   t | jƒS rh   )r&   re   rj   ri   ri   rl   rm     s    zCoshRule.evalNrw   ri   ri   ri   rl   r®   
  s   r®   c                   @  s0   e Zd ZU dZded< ded< ddœdd„ZdS )	Ú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     s    zExpRule.evalNr‚   ri   ri   ri   rl   r¯     s   
r¯   c                   @  s(   e Zd ZU dZded< ddœdd„ZdS )ÚReciprocalRulezintegrate(1/x, x) -> ln(x)r   r   rf   c                 C  s
   t | jƒS rh   )r    r   rj   ri   ri   rl   rm      s    zReciprocalRule.evalNr‚   ri   ri   ri   rl   r°     s   
r°   c                   @  s   e Zd ZdZddœdd„ZdS )Ú
ArcsinRulez'integrate(1/sqrt(1-x**2), x) -> asin(x)r   rf   c                 C  s
   t | jƒS rh   )r3   re   rj   ri   ri   rl   rm   '  s    zArcsinRule.evalNrw   ri   ri   ri   rl   r±   $  s   r±   c                   @  s   e Zd ZdZddœdd„ZdS )ÚArcsinhRulez'integrate(1/sqrt(1+x**2), x) -> asin(x)r   rf   c                 C  s
   t | jƒS rh   )r(   re   rj   ri   ri   rl   rm   .  s    zArcsinhRule.evalNrw   ri   ri   ri   rl   r²   +  s   r²   c                   @  s8   e Zd ZU dZded< ded< ded< 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    z ReciprocalSqrtQuadraticRule.evalNr‚   ri   ri   ri   rl   r³   2  s
   
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	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                   sb  | j | j| j| j ¡ | jf\}}}‰ ‰g ‰ˆ  ¡ ‰ ttˆ ƒd ƒD ]v}tˆ ƒd | }ˆ | ||  }ˆ |¡ ˆ |d   d| d | d | 8  < ˆ |d   |d | | 8  < qBˆ d ˆ d  }}t	||ˆ  |ˆd   ƒ}	||| d|   }
|
dk�rd}n"t
td|	 ˆƒdd�}|
| ¡  }t‡ ‡‡fdd	„ttˆƒƒD ƒ|| fžŽ |	 | S )
Nr·   rQ   r�   éþÿÿÿr   F©Ú
degeneratec                 3  s*   | ]"}ˆ| ˆt ˆ ƒd  |   V  qdS )r·   N)Úlen©rŠ   Úi©r»   Z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Úsry   ZI0Ústepri   rÂ   rl   rm   F  s2    &
("

ÿÿÿÿzSqrtQuadraticDenomRule.evalNr‚   ri   ri   ri   rl   rº   >  s   
rº   c                   @  s8   e Zd ZU dZded< ded< ded< ddœdd„Zd	S )
Ú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.evalNr‚   ri   ri   ri   rl   rÍ   b  s
   
rÍ   c                   @  s6   e Zd ZU dZded< ddœdd„Zddœd	d
„ZdS )ÚAlternativeRulez Multiple ways to do integration.r†   Úalternativesr   rf   c                 C  s   | j d  ¡ S ©Nr   )rÐ   rm   rj   ri   ri   rl   rm   s  s    zAlternativeRule.evalrn   c                 C  s   t dd„ | jD ƒƒS )Nc                 s  s   | ]}|  ¡ V  qd S rh   rŒ   r‰   ri   ri   rl   r‹   w  s     z5AlternativeRule.contains_dont_know.<locals>.<genexpr>)r�   rÐ   rj   ri   ri   rl   ro   v  s    z"AlternativeRule.contains_dont_knowNr}   ri   ri   ri   rl   rÏ   n  s   
rÏ   c                   @  s,   e Zd ZdZddœdd„Zddœdd„Zd	S )
ÚDontKnowRulezLeave the integral as is.r   rf   c                 C  s   t | j| jƒS rh   )rR   rd   re   rj   ri   ri   rl   rm   }  s    zDontKnowRule.evalrn   c                 C  s   dS ©NTri   rj   ri   ri   rl   ro   €  s    zDontKnowRule.contains_dont_knowN)rp   rq   rr   ru   rm   ro   ri   ri   ri   rl   rÒ   z  s   rÒ   c                   @  s   e Zd ZdZddœdd„ZdS )ÚDerivativeRulezintegrate(f'(x), x) -> f(x)r   rf   c                 C  sb   t | jtƒst‚t| jjƒ}t|ƒD ]*\}\}}|| jkr$||d f||<  qPq$t| jjf|žŽ S ©NrQ   )	Ú
isinstancerd   r   rœ   ÚlistÚvariable_countÚ	enumeratere   Úexpr)rk   rØ   rÁ   ÚvarÚcountri   ri   rl   rm   ‡  s    
zDerivativeRule.evalNrw   ri   ri   ri   rl   rÔ   „  s   rÔ   c                   @  s>   e Zd ZU dZded< ded< ddœdd„Zd	dœd
d„ZdS )ÚRewriteRulez;Rewrite integrand to another form that is easier to handle.r   Ú	rewrittenrc   r{   rf   c                 C  s
   | j  ¡ S rh   )r{   rm   rj   ri   ri   rl   rm   —  s    zRewriteRule.evalrn   c                 C  s
   | j  ¡ S rh   r|   rj   ri   ri   rl   ro   š  s    zRewriteRule.contains_dont_knowNr}   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)rp   rq   rr   ru   ri   ri   ri   rl   rß   ž  s   rß   c                   @  s2   e Zd ZU ded< ddœdd„Zddœdd	„Zd
S )ÚPiecewiseRulez%Sequence[tuple[Rule, bool | Boolean]]Úsubfunctionsr   rf   c                 C  s   t dd„ | jD ƒŽ S )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.evalrn   c                 C  s   t dd„ | jD ƒƒS )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   ro   ¬  s    z PiecewiseRule.contains_dont_knowN©rp   rq   rr   rs   rm   ro   ri   ri   ri   rl   rà   ¤  s   
rà   c                   @  sB   e Zd ZU ded< ded< ded< ddœdd„Zd	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.evalrn   c                 C  s
   | j  ¡ S rh   r|   rj   ri   ri   rl   ro   ¾  s    z HeavisideRule.contains_dont_knowNræ   ri   ri   ri   rl   rç   °  s
   
rç   c                   @  s4   e Zd ZU ded< ded< ded< ddœdd„ZdS )	ÚDiracDeltaRuler   rÇ   r´   rµ   rf   c                 C  sR   | j | j| j| jf\}}}}|dkr8t|||  ƒ| S t|||  |d ƒ| S ©Nr   rQ   )rÇ   r´   rµ   re   r8   r9   ©rk   rÇ   r´   rµ   r¹   ri   ri   rl   rm   È  s    zDiracDeltaRule.evalN©rp   rq   rr   rs   rm   ri   ri   ri   rl   rê   Â  s   
rê   c                   @  sR   e Zd ZU ded< ded< ded< ded< ded< dd	œd
d„Zd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|t‚|d }t|| |ƒ}t|ƒdks¢t‚t|d ƒ\}}t|tƒræ|}|}	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œ   r\   rY   rÖ   r)   r3   r2   r4   r*   r{   rm   Útrigsimprñ   )rk   rï   rð   r¹   Ztrig_functionZrelationZnumerÚdenomZoppositeZ
hypotenuseZadjacentZinverseÚsubstitutionri   ri   rl   rm   ×  s@    
üÿzTrigSubstitutionRule.evalrn   c                 C  s
   | j  ¡ S rh   r|   rj   ri   ri   rl   ro   þ  s    z'TrigSubstitutionRule.contains_dont_knowNræ   ri   ri   ri   rl   rî   Ï  s   
'rî   c                   @  s8   e Zd ZU dZded< ded< ded< ddœdd„Zd	S )
Ú
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.evalNr‚   ri   ri   ri   rl   rö     s
   
rö   c                   @  s   e Zd ZU ded< dS )ÚOrthogonalPolyRuler   rÇ   N©rp   rq   rr   rs   ri   ri   ri   rl   r÷     s   
r÷   c                   @  s,   e Zd ZU ded< ded< 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.evalNrí   ri   ri   ri   rl   rù     s   
rù   c                   @  s$   e Zd ZU ded< 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.evalNrí   ri   ri   ri   rl   rû      s   
rû   c                   @  s   e Zd Zddœdd„ZdS )ÚChebyshevTRuler   rf   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.evalN©rp   rq   rr   rm   ri   ri   ri   rl   rý   ,  s   rý   c                   @  s   e Zd Zddœdd„ZdS )ÚChebyshevURuler   rf   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.evalNrÿ   ri   ri   ri   rl   r   6  s   r   c                   @  s   e Zd Zddœdd„ZdS )ÚLegendreRuler   rf   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.evalNrÿ   ri   ri   ri   rl   r  ?  s   r  c                   @  s   e Zd Zddœdd„ZdS )ÚHermiteRuler   rf   c                 C  s(   | j | j }}t|d |ƒd|d   S r  )rÇ   re   rJ   rþ   ri   ri   rl   rm   H  s    zHermiteRule.evalNrÿ   ri   ri   ri   rl   r  F  s   r  c                   @  s   e Zd Zddœdd„ZdS )ÚLaguerreRuler   rf   c                 C  s&   | j | j }}t||ƒt|d |ƒ S rÕ   )rÇ   re   rK   rþ   ri   ri   rl   rm   O  s    zLaguerreRule.evalNrÿ   ri   ri   ri   rl   r  M  s   r  c                   @  s$   e Zd ZU ded< ddœdd„ZdS )ÚAssocLaguerreRuler   r´   rf   c                 C  s   t | jd | jd | jƒ S rÕ   )rL   rÇ   r´   re   rj   ri   ri   rl   rm   X  s    zAssocLaguerreRule.evalNrí   ri   ri   ri   rl   r  T  s   
r  c                   @  s   e Zd ZU ded< ded< dS )ÚIRuler   r´   rµ   Nrø   ri   ri   ri   rl   r  \  s   
r  c                   @  s   e Zd Zddœdd„ZdS )ÚCiRuler   rf   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  s    zCiRule.evalNrÿ   ri   ri   ri   rl   r  b  s   r  c                   @  s   e Zd Zddœdd„ZdS )ÚChiRuler   rf   c                 C  s>   | j | j| j  }}}t|ƒt|| ƒ t|ƒt|| ƒ  S rh   )r´   rµ   re   r#   r?   r&   rA   r  ri   ri   rl   rm   k  s    zChiRule.evalNrÿ   ri   ri   ri   rl   r	  i  s   r	  c                   @  s   e Zd Zddœdd„ZdS )ÚEiRuler   rf   c                 C  s*   | j | j| j  }}}t|ƒt|| ƒ S rh   )r´   rµ   re   r   rB   r  ri   ri   rl   rm   r  s    zEiRule.evalNrÿ   ri   ri   ri   rl   r
  p  s   r
  c                   @  s   e Zd Zddœdd„ZdS )ÚSiRuler   rf   c                 C  s>   | j | j| j  }}}t|ƒt|| ƒ t|ƒt|| ƒ  S rh   )r´   rµ   re   r-   r>   r,   r@   r  ri   ri   rl   rm   y  s    zSiRule.evalNrÿ   ri   ri   ri   rl   r  w  s   r  c                   @  s   e Zd Zddœdd„ZdS )ÚShiRuler   rf   c                 C  s>   | j | j| j  }}}t|ƒt|| ƒ t|ƒt|| ƒ  S rh   )r´   rµ   re   r&   r?   r#   rA   r  ri   ri   rl   rm   €  s    zShiRule.evalNrÿ   ri   ri   ri   rl   r  ~  s   r  c                   @  s   e Zd Zddœdd„ZdS )ÚLiRuler   rf   c                 C  s*   | j | j| j  }}}t|| | ƒ| S rh   )r´   rµ   re   rC   r  ri   ri   rl   rm   ‡  s    zLiRule.evalNrÿ   ri   ri   ri   rl   r  …  s   r  c                   @  s4   e Zd ZU ded< ded< ded< ddœdd„ZdS )	ÚErfRuler   r´   rµ   r¶   rf   c                 C  s  | j | j| j| jf\}}}}|jrÐt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.evalNrí   ri   ri   ri   rl   r  Œ  s   
r  c                   @  s4   e Zd ZU ded< ded< ded< ddœdd„ZdS )	Ú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   ¤  s    <<ÿÿzFresnelCRule.evalNrí   ri   ri   ri   rl   r  ž  s   
r  c                   @  s4   e Zd ZU ded< ded< ded< ddœdd„ZdS )	Ú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 r  )r´   rµ   r¶   re   r)   r   r  r,   r=   r-   r<   r¸   ri   ri   rl   rm   ±  s    <<ÿÿzFresnelSRule.evalNrí   ri   ri   ri   rl   r  «  s   
r  c                   @  s,   e Zd ZU ded< ded< ddœdd„ZdS )Ú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.evalNrí   ri   ri   ri   rl   r  ¸  s   
r  c                   @  s,   e Zd ZU ded< ded< ddœdd„ZdS )Ú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    zUpperGammaRule.evalNrí   ri   ri   ri   rl   r  Á  s   
r  c                   @  s,   e Zd ZU ded< ded< ddœdd„ZdS )Ú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   Ð  s    zEllipticFRule.evalNrí   ri   ri   ri   rl   r  Ë  s   
r  c                   @  s,   e Zd ZU ded< ded< ddœdd„ZdS )Ú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   Ù  s    zEllipticERule.evalNrí   ri   ri   ri   rl   r  Ô  s   
r  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ƒr2| ˆ ¡t|ƒd  S t| tƒrT| ˆ ¡ t|ƒd  S t| tƒrx| ˆ ¡t|ƒ t|ƒ S t| tƒrž| ˆ ¡ 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  s   | ]}t |ˆ ƒV  qd S rh   )Úmanual_diff©rŠ   Úarg©r  ri   rl   r‹   õ  s     zmanual_diff.<locals>.<genexpr>rQ   )ÚargsrÖ   r.   Údiffr1   r/   r0   r   Úsumr   r¿   r   r  )Úfr  r  ri   r  rl   r  â  s     





"r  c                   sÀ   t |ƒdkr>|d }t|ttfƒr,| ¡ }qZt|ƒsZtdƒ‚nt |ƒdkrR|g}ntdƒ‚g }|D ]J\}‰ t|tƒrb|jd ‰|  	‡fdd„‡ fdd„¡} | 
ˆtˆ ƒf¡ qb|  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   r!  )Únewri   rl   r#    r$  )r¿   rÖ   r   r   Úitemsra   Ú
ValueErrorr    r  Úreplacer¡   r   r“   r×   )rÚ   r  ÚsequenceZnew_subsÚoldri   )r%  r"  rl   Úmanual_subsû  s$    




ÿr+  c                   s´   g }‡ ‡‡fdd„}ddœ‡fdd„}‡‡fdd„‰t t ˆˆ ƒ|ˆ ƒ ¡ƒD ]`}|ˆkr\qNt|ˆƒ}|||ƒ}|d	k	rN|\}	}|ˆ  ˆˆ¡kr’qN||	|f}
|
|krN| |
¡ qN|S )
Nc                   s¦   |dkrdS ˆ | }t d || ˆ¡ƒ t|| ˆƒ ¡ }| ˆ¡rDdS ˆ  ˆ¡r˜| ˆ¡r˜t‡fdd„ˆ  ¡ D ƒƒ}t‡fdd„| ¡ D ƒƒ}||kr˜dS |jˆdd�S )Nr   Fz!substituted: {}, u: {}, u_var: {}c                 3  s   | ]}t |ˆ ƒV  qd S rh   ©rU   ©rŠ   Útr  ri   rl   r‹   -  s     z;find_substitutions.<locals>.test_subterm.<locals>.<genexpr>c                 3  s   | ]}t |ˆ ƒV  qd S rh   r,  r-  )r�   ri   rl   r‹   .  s     )Zas_Add)	rb   Úformatr+  ÚcancelÚhas_freeÚis_rational_functionÚmaxÚas_numer_denomÚas_independent)r—   Úu_diffÚsubstitutedZ
deg_beforeZ	deg_after)rd   r  r�   ri   rl   Útest_subterm"  s    
z(find_substitutions.<locals>.test_subtermr   ©Útermc                   sŠ   g }g }t ddd„ gd�}|  t¡D ]F}|jd }ˆ |jkr>q$| |ˆ  ¡}|r`| || ¡ q$| |¡ q$|r†| tt|ƒˆ  ƒ¡ |S )NrÇ   c                 S  s   | j S rh   )Ú
is_Integer©rÇ   ri   ri   rl   r#  6  r$  z:find_substitutions.<locals>.exp_subterms.<locals>.<lambda>©Ú
propertiesr   )r   rò   r   r  Úfree_symbolsÚmatchr¡   rW   )r:  Zlinear_coeffsÚtermsrÇ   r•   r  r@  r  ri   rl   Úexp_subterms3  s    

z(find_substitutions.<locals>.exp_subtermsc                   sZ  t ˆ ttfttttf˜ƒr&ˆ jd gS t ˆ tt	t
ttfƒrFˆ jd gS t ˆ ttfƒr`ˆ jd gS t ˆ tƒrvˆ jd gS t ˆ tƒr¬g }ˆ jD ]}| |¡ | ˆ|ƒ¡ qŠ|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ƒ�rVg }ˆ jD ]}| |¡ | ˆ|ƒ¡ �q2|S g S )	Nr   rQ   r·   é   c                   s   g | ]}|  ˆ ¡r|‘qS ri   ©Úhasr  r  ri   rl   rä   W  s     
 zAfind_substitutions.<locals>.possible_subterms.<locals>.<listcomp>c                   s8   g | ]0}d |  k r&t ˆ jd  ƒk rn qˆ j| ‘qS )rQ   )Úabsr  r   )rŠ   rÉ   r9  ri   rl   rä   Y  s
     
 ÿc                 S  s   g | ]}|j r|‘qS ri   )r‘   r-  ri   ri   rl   rä   \  s    ÿ)rÖ   r+   r!   Úinverse_trig_functionsr   r    r8   r  rG   rH   rI   rJ   rK   rM   rL   rN   r   r¡   Úextendr   r;  rT   r   Zis_Addr   )r:  Úrr—   r  )Úpossible_subtermsr  r9  rl   rJ  D  sJ    
  þ  ÿ







z-find_substitutions.<locals>.possible_subtermsF)r×   ÚdictÚfromkeysr  r“   r¡   )rd   r  r�   Úresultsr8  rB  r—   r6  Znew_integrandry   rõ   ri   )rd   rJ  r  r�   rl   Úfind_substitutions  s"    #


rN  c                   s   ‡ ‡fdd„}|S )z$Strategy that rewrites an integrand.c                   s\   | \}}t d |ˆ|¡ƒ ˆ | Ž rXˆ| Ž }||krXt||ƒ}t|tƒsX|rXt||||ƒS d S )Nz/Integral: {} is rewritten with {} on symbol: {})rb   r/  Úintegral_stepsrÖ   rÒ   rÝ   )Úintegralrd   r  rÞ   r{   ©r`   Úrewriteri   rl   Ú	_rewriterx  s    
zrewriter.<locals>._rewriterri   )r`   rR  rS  ri   rQ  rl   Úrewriterv  s    	rT  c                   s   ‡ ‡fdd„}|S )zAStrategy that rewrites an integrand based on some other criteria.c                   s`   | \} }|\}}t d |ˆ|| ¡ƒ | t|ƒ }ˆ |Ž r\ˆ|Ž }||kr\t|||t||ƒƒS d S )Nz@Integral: {} is rewritten with {} on symbol: {} and criteria: {})rb   r/  r×   rÝ   rO  )ÚcriteriarP  rd   r  r  rÞ   rQ  ri   rl   Ú_proxy_rewriter…  s    z'proxy_rewriter.<locals>._proxy_rewriterri   )r`   rR  rV  ri   rQ  rl   Úproxy_rewriterƒ  s    	rW  c                   s   ‡ 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   )rZ  r[  ri   rY  rl   Úmultiplexer�  s    r\  c                    s   ‡ fdd„}|S )zHStrategy that makes an AlternativeRule out of multiple possible results.c                   s¬   g }d}t dƒ ˆ D ]L}|d }t d ||¡ƒ || ƒ}|rt|tƒs|| kr||kr| |¡ qt|ƒdkrv|d S |r¨dd„ |D ƒ}|ršt| |fžŽ S t| |fžŽ 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   r/  rÖ   rÒ   r¡   r¿   rÏ   )rP  ZaltsrÜ   r£   r”   Zdoable©Úrulesri   rl   Ú_alternativesš  s(    ÿÿz#alternatives.<locals>._alternativesri   )r_  r`  ri   r^  rl   rÐ   ˜  s    rÐ   c                 C  s   t | Ž S rh   )rv   ©rP  ri   ri   rl   Úconstant_rule°  s    rb  c                 C  sÆ   | \}}|  ¡ \}}||jkrRt|tƒrRt|d ƒdkrDt|||ƒS t||||ƒS ||jkrÂt|tƒrÂt||||ƒ}tt	|ƒj
ƒr†|S t	|ƒj
rštd|ƒS t|||tt	|ƒdƒftd|ƒdfgƒS d S )NrQ   r   T)r’   r?  rÖ   r   r[   r°   r~   r¯   r   r    Úis_zerorv   rà   r   )rP  rd   r  r   Zexptr£   ri   ri   rl   Ú
power_rule³  s     

þrd  c                 C  s0   | \}}t |jd tƒr,t||t|jd ƒS d S rÑ   )rÖ   r  r   r¯   r   ©rP  rd   r  ri   ri   rl   Úexp_ruleÈ  s    rf  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 ]j}t||ƒr@| |d¡}|j| ˆ kr@t‡ fdd„|jd |… D ƒƒs@|| |ˆ f|jd |… žŽ   S q@d S )NrC  r·   rQ   c                 3  s   | ]}|  ˆ ¡V  qd S rh   rD  )rŠ   r�   r  ri   rl   r‹   ã  s     z'orthogonal_poly_rule.<locals>.<genexpr>)rN   rù   rM   rû   rG   rý   rH   r   rI   r  rJ   r  rK   r  rL   r  rÖ   Úgetr  r�   )rP  Zorthogonal_poly_classesZorthogonal_poly_var_indexrd   ÚklassZ	var_indexri   r  rl   Úorthogonal_poly_ruleÎ  s@            ø   ý
ÿri  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 ]h\}}}}t|
|ƒ�r|
 |¡‰ ˆ �rt‡ fdd„tD ƒƒ}|d k�sT||Ž �r|||f|žŽ   S �qd S )Nr´   c                 S  s   | j  S rh   ©rc  r!  ri   ri   rl   r#  ï  r$  z'special_function_rule.<locals>.<lambda>©Úexcluder>  rµ   ©rm  r¶   rÉ   c                 S  s   | j  S rh   rk  r!  ri   ri   rl   r#  ò  r$  rÊ   c                 S  s   | j o
| j S rh   )Úis_nonnegativeÚ
is_integerr!  ri   ri   rl   r#  ô  r$  r·   F©ÚevaluaterQ   c                 S  s   | |kS rh   ri   ©r´   rÉ   ri   ri   rl   r#    r$  c                 S  s   | |kS rh   ri   rs  ri   ri   rl   r#  
  r$  c                 3  s&   | ]}ˆ   |¡d k	rˆ   |¡V  qd S rh   )rg  )rŠ   Úw©r@  ri   rl   r‹     s    ÿz(special_function_rule.<locals>.<genexpr>) rj  r   Ú_symbolÚ_wildsrH  r   r   r
  r,   r  r#   r	  r-   r  r&   r  r   r    r  r  r  r  r  rP   r  r)   r  r  r“   rÖ   r@  Útuple)rP  rd   r  r´   rµ   r¶   rÉ   rÊ   Zlinear_patternZquadratic_patternZ
_integrandÚtype_ÚpatternÚ
constraintr£   Z	wild_valsri   ru  rl   Úspecial_function_ruleì  sR    ÿ  ÿ ÿò
r|  rš   )Úgeneric_stepÚdegenerate_steprg   c                   sl   |d kr|S t |tƒr,‡ fdd„|jD ƒ}n
|ˆ fg}t |tƒrL||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‚  ra  c                   sÌ   | \}‰t dˆgd�‰t dˆdgd�‰ˆˆˆ  ‰tj‰G dd„ dtƒ‰ ddd	œ‡ ‡‡‡‡‡‡fd
d„‰zˆ|ƒ\}}W n ˆ k
rŽ   Y d S X ˆtjkr d }nt| ˆd¡ˆƒ}t|ˆ||ƒ}tˆ||ƒS )Nr´   rn  rµ   r   c                   @  s   e Zd ZdS )z nested_pow_rule.<locals>.NoMatchNr¥   ri   ri   ri   rl   ÚNoMatch/  s   rƒ  r   ztuple[Expr, Expr])rÚ   rg   c                   s  |   ˆ¡stjtjfS | jrŽ|  ¡ \}}|s8tjtjfS ‡fdd„|D ƒ}dd„ |D ƒ}| tj¡ t|ƒdkrŠ| ¡ t	dd„ |D ƒŽ fS ˆ ‚| j
rÈ| j| j }}|  ˆ¡r°ˆ ‚ˆ|ƒ\}}||| fS |  ˆ¡}	|	�r
|	ˆ |	ˆ  }
}ˆ|
|  }t|dƒ‰|tjfS ˆ ‚d S )	Nc                   s   g | ]}ˆ |ƒ‘qS ri   ri   )rŠ   r:  )Ú_get_base_expri   rl   rä   9  s     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>:  s     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‹   =  s     z9nested_pow_rule.<locals>._get_base_exp.<locals>.<genexpr>r   )r1  r   ÚOnerü   Úis_MulZas_coeff_mulÚdiscardr¿   Úpopr   r‘   r   r   r@  r   )rÚ   rå   rA  rM  Úbasesrµ   rÊ   Zbase_Zsub_expr@  r´   ©rƒ  r„  Za_Zb_r€  rz  r¹   ri   rl   r„  2  s2    




z&nested_pow_rule.<locals>._get_base_exp)r   r   r�  Ú	Exceptionrv   r“   rƒ   r‚  )rP  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   ¡‰ˆsfdS dd	œ‡ ‡fd
d„}‡fdd„|||fD ƒ\}}}t|dƒ}|r°|tjkr¶d}	n0|jrÌt|| ˆƒ}	ntt	||ˆ  | ˆƒƒ}	t
d| d ƒdk�rf| d|  ||d d|    }
}t|dƒ}d}|tjk	�rbtdt|ˆ|
 d  ƒ ˆˆ|
 tjƒ}|tjk�rr|S tˆ ˆ|||ƒ}t|||ƒ}|j�rZ|j�rZg }t|d| d|
ft|dk|dk ƒft|d|d|
ft|dk|dkƒffD ]@\}}|tjk�r||Ž   S |tjk	�rè| ||Ž |f¡ �qè|�rV|j�sH| |tjf¡ tˆ ˆ|ƒ}n|}t|||	ƒS |tjk�rŽtˆ ˆ|||ƒ}t|||	ƒS dS )zm
    Set degenerate=False on recursive call where coefficient of quadratic term
    is assumed non-zero.
    r´   rn  rµ   r¶   r   r·   Nrc   rf   c                   sÐ   t dƒ}dt|| || ˆ| d   ƒ }t|| ƒˆ|  }dt|ƒ }	d }
|ˆk	r`|}
|}dt|||d   ƒ }| ||ƒ}|	dkržt|	| ˆ|	||ƒ}|
d k	r¶t|ˆ||
|ƒ}|dkrÌtˆ ˆ||ƒ}|S )Nr—   rQ   r·   r   )r   r)   rx   rŽ   rß   )Z	RuleClassr´   Zsign_ar¶   Zsign_cÚhr�   rÞ   Zquadratic_basery   r�   Zstandard_formr{   ©rd   r  ri   rl   Úmake_inverse_trigj  s"    $
z,inverse_trig_rule.<locals>.make_inverse_trigc                   s   g | ]}ˆ   |tj¡‘qS ri   ©rg  r   rü   rÀ   ru  ri   rl   rä   }  s     z%inverse_trig_rule.<locals>.<listcomp>rQ   rú   r�   )r’   r   r@  r   r   r�  rc  rv   Úsqrt_linear_rulerÆ   r[   rƒ   r)   ZNegativeOneÚfalser³   r‚  Zis_realr±   rS   r²   r¡   Úis_positiverà   ÚHalfrÍ   )rP  r¾   r   r   r´   rµ   r¶   r�  r€  r~  rŽ  ÚkZnon_square_condZsquare_stepr}  rÌ   r_  r  rã   ri   )rd   r@  r  rl   rÅ   [  sX    
$
(" þrÅ   c                   s6   | \}‰ ‡ fdd„|  ¡ D ƒ}d |kr*d S t|ˆ |ƒS )Nc                   s   g | ]}t |ˆ ƒ‘qS ri   )rO  )rŠ   Úgr  ri   rl   rä   ©  s   ÿzadd_rule.<locals>.<listcomp>)Zas_ordered_termsr…   )rP  rd   rM  ri   r  rl   Úadd_rule§  s
    
ÿr˜  c                 C  sD   | \}}|  |¡\}}|dkr@t||ƒ}|d k	r@t|||||ƒS d S rÕ   )r5  rO  rx   )rP  rd   r  rÈ   r   Ú	next_stepri   ri   rl   Úmul_rule®  s    
rš  z*tuple[Expr, Expr, Expr, Expr, Rule] | Nonerf   c                   s0  ‡ fdd„}ddœdd„}|t ƒ|tŽ ||ttƒ|tƒg}tdƒ}t| t ft˜ƒrZ||  } t|ƒD �]Æ\}}|| ƒ}|rb|\}	}
ˆ |	jkrš|	 	|¡sš d S |	 
|d¡}	|
 
|d¡}
||krÊ|	 ˆ ¡sÊ d S t|	t ƒrúd|
 }| ˆ ¡rút|ˆ ƒdkrú d S ||k�rb|
j�s$|
 	t¡�s$t|
tƒ�rbt|
ˆ ƒ}| ¡ �r> d S |	 ˆ ¡}| ¡ }|	|
|||f  S d	}|d
k �rvd}nv||k�r¤|
j�r¤tdd„ |
jD ƒƒ�r¤d}nH||d d … D ]6}|| ƒ}|�r´|d  
|d¡ |
¡�r´d} �qì�q´|rb|	 ˆ ¡}tt|
ƒˆ ƒ}| ¡ sb| ¡ }|	|
|||f  S qbd S )Nc                   sX   |   ¡  ¡ } t| tƒs| js g n‡ fdd„| jD ƒ}|rTt|Ž }| |   ¡ }||fS d S )Nc                   s   g | ]}|  ˆ ¡r|‘qS ri   )Zis_algebraic_exprr  r  ri   rl   rä   À  s     
 z;_parts_rule.<locals>.pull_out_algebraic.<locals>.<listcomp>)r0  ZtogetherrÖ   r*   r‡  r  r   )rd   Z	algebraicr—   r˜   r  ri   rl   Úpull_out_algebraic¼  s    ÿz'_parts_rule.<locals>.pull_out_algebraicz*Callable[[Expr], tuple[Expr, Expr] | None]rf   c                    s   dddœ‡ fdd„}|S )Nr   ztuple[Expr, Expr] | None)rd   rg   c                   sJ   t ‡ fdd„ˆD ƒƒrF‡fdd„ˆ jD ƒ}|rFt|Ž }ˆ | }||fS d S )Nc                 3  s   | ]}ˆ   |¡V  qd S rh   rD  ©rŠ   r   ©rd   ri   rl   r‹   È  s     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©r  ri   rl   r‹   Ê  s     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�   r  r   )rd   r  r—   r˜   r   r�  rl   Úpull_out_u_rlÇ  s    z6_parts_rule.<locals>.pull_out_u.<locals>.pull_out_u_rlri   )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   )r    rG  r-   r,   r   r   rÖ   rÙ   r?  rE  r“   Úis_polynomialrU   Zis_Derivativer+   rO   rO  ro   r  rm   r  ÚallÚequalsr[   )rd   r  r›  r£  Zliate_rulesÚdummyÚindexr£   r”   r—   r˜   Zrec_dvr™   Údur�   ÚacceptZlrulerI  ri   r  rl   Ú_parts_rule¹  sr    
 þ

ÿ
ÿ



ÿÿ

r­  c              
     s  | \}‰|  ¡ \}}t|ˆƒ}g }|�rœ|\}}}}}	td |||||	¡ƒ | |¡ t|tƒrdd S t|ttt	t
tfƒr¦| ˆti¡}
t|
 dkr–d S t|
  d7  < tdƒD ]ì}td ||||¡ƒ || |  ¡ }|dkrä �qœˆ|jk�r@t|ˆdd„ |D ƒdt|ƒ | ƒ}|dk�r8|�r8t|| ˆ|||ƒ}|  S ||   ¡ \}}t|ˆƒ}|�r”|\}}}}}	||9 }||9 }| |||||	f¡ q® �qœq®‡ ‡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–   rO  )Ústepsrd   r—   r˜   r�   r«  r™   ©Úmake_second_stepr  ri   rl   r°  I  s    $z$parts_rule.<locals>.make_second_stepr   )Zas_coeff_Mulr­  rb   r/  r¡   rÖ   rR   r-   r,   r   r&   r#   ÚxreplaceÚ_cache_dummyÚ_parts_u_cacherÄ   r0  r?  rž   r¿   rx   r–   )rP  rd   ry   r”   r®  r—   r˜   r�   r«  r™   Úcachekeyrå   r    r£   Znext_constantZnext_integrandri   r¯  rl   Ú
parts_rule  sZ    


ÿý
$rµ  c                 C  sF  | \}}|t |ƒkrt||ƒS |t|ƒkr4t||ƒS |t|ƒd krNt||ƒS |t|ƒd krht||ƒS t|t	ƒrˆt |j
Ž t|j
Ž  }nªt|tƒr¨t|j
Ž t |j
Ž  }nŠt|tƒrê|j
d }t|ƒd t	|ƒt|ƒ  t|ƒt	|ƒ  }nHt|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.   r  r/   rÝ   rO  )rP  rd   r  rÞ   r  ri   ri   rl   Ú	trig_ruleW  s2    







ÿ
ÿr·  c                 C  sH   | \}}|t |ƒt|ƒ kr&t||ƒS |t|ƒt|ƒ krDt||ƒS d S rh   )r1   r.   r¨   r0   r/   r©   re  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kr¨|S |dt| ƒ t|ƒ  }	t| | ƒ}
d||
  }d||
  }t||||
 ƒt| |d|t||||
 ƒƒg}||  }}t	|||ƒ}|	dk�rVt
|	|d	d
�}t|||	||ƒ}t||||ƒ}|tjk�rt|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�r0d S tdƒ}||d|   }| |||d|   ¡}t||ƒ}|�r€t|||||ƒS d S t d|gd�}| || | ||d  ||  |  ¡}|�rÐ|| || || || || f\}}}}}|j�rúd S ||d  ||  | }|d|  }d| | | }| | | }tdƒ}t||||t|d |ƒƒ}|dk�r„t|| | |||| |ƒ}|j�r�|S t|| |ƒ}t	||||gƒ} || | ||  }!t|||!| ƒS d S )Nr´   rn  rµ   r¶   r·   r   rQ   r�   Frq  r¼   TrÉ   r—   rÊ   )r   r@  rö   r  r   r�  r)   r°   rx   r…   r   rÝ   r“  rà   r~   r   rc  r   r“   rO  rŽ   )"rP  rd   r  r´   rµ   r¶   r@  Zgeneral_ruleZpositive_condrÈ   ry   Úr1Úr2Z	log_stepsrÞ   ÚsubZnegative_stepÚpowerrÉ   Zmatch2r—   r�   Z
integrand2r™  rÊ   Zmatch3ÚdenominatorÚconstZnumer1Znumer2Zstep1Zstep2r‡   Z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sH||
jkrlqH|jsx dS |
 |||  ¡}|s�qH|| ||  }}|| |ˆ  ks¼ˆ | j	sÂ dS ˆ dksÜˆ | dkt
jkræ|| }‰ | |
¡ | |¡ | |j¡ qHˆ dk�rdS t|ƒ‰|ˆ |  dˆ  }tdƒ‰| ‡ ‡‡fdd	„t|||ƒD ƒ¡ |ˆˆ | ˆ  ¡}t|ˆˆd   ˆ ˆ  ˆƒ}| ¡ �sút||ˆ||ƒ}tˆ dƒ}|t
jk	�rö| t |d¡¡}t||ƒ}t||||f|t
jfgƒ}|S dS )
z*
    Substitute common (a+b*x)**(1/n)
    r´   rn  rµ   r   NrQ   r—   c                   s<   i | ]4\}}}|t j|  |ˆ  t j|  ˆˆ|   “qS ri   )r   r†  )rŠ   r   rµ   Úq©Zb0Úq0r—   ri   rl   Ú
<dictcomp>ç  s   ÿ z$sqrt_linear_rule.<locals>.<dictcomp>)r   rò   r   r   r   r;  r?  Zis_Rationalr@  ro  r   r�  r¡   rÀ  rV   r   r“   ÚziprO  ro   rŽ   r   rK  rL  rà   )rP  rd   r¹   r´   rµ   Za0rŠ  ÚqsÚbsZpow_r   r•   r@  Za1Úb1Zu_xr7  r{   rÌ   r€  Z
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 krÂd S tˆdƒ}|rÚ|tjkràd }n@ˆjrþt|tˆ ƒ|  ˆƒ}n"t	t
|tˆ ˆˆ  ƒ|  ˆƒƒ}dddœ‡ ‡‡‡fdd„}	|dk�rª|ˆ ˆˆ  ˆˆd   |d d   }
|
 ¡ tˆ ˆˆ  ˆˆd   ƒ }|	|
|ƒ}t|ˆ||ƒ}n|dk�rÀ|	||ƒ}nd S t|||ƒS )Nr´   rn  rµ   r¶   r   r   rÇ   c                 S  s   | j o
| jS rh   )r;  Úis_oddr<  ri   ri   rl   r#  ú  r$  z%sqrt_quadratic_rule.<locals>.<lambda>r=  r·   rX   r   )Ú
numer_polyrd   c              	     s˜  t ˆ ˆˆ  ˆˆd   ƒ}|  ¡ }|dk�rz|dkr>|  ¡ ntj|  ¡ f\}}|dˆ  }||ˆ  }dˆ ˆ ˆ | }d }	d }
|dkrîtdƒ}tdt |ƒ ||tj ƒ}t	|ˆ|ˆ ˆˆ  ˆˆd   |ƒ}
|dkrît
|| ˆ|||
ƒ}
|dk�r0ttd| ˆƒdd�}	|dk�r0t
|| ˆ|d| |	ƒ}	|
�rn|	�rnt|| || dd�}t|ˆ|t|ˆ|
|	gƒƒ}n
|
�pv|	}n|  ¡ }t|ˆˆ ˆˆ|ƒ}|S )Nr·   rQ   r   r—   Fr½   rq  )r)   rU   Z
all_coeffsr   rü   Úas_exprr   r~   r•  rŽ   rx   rÅ   rÆ   r   rÝ   r…   rº   )rÉ  rd   rô   ÚdegrÊ   rÉ   ÚAÚBZpre_substituteZconstant_stepZlinear_stepr—   Zpow_ruleÚaddrÌ   r»   ©r´   rµ   r¶   r¹   ri   rl   Úsqrt_quadratic_denom_rule  s4    
"$

z6sqrt_quadratic_rule.<locals>.sqrt_quadratic_denom_rulerQ   r�   )r   r@  r)   Zas_polyr   r   r�  rc  rO  r’  rÆ   rÊ  rÝ   r‚  )rP  r¾   rd   r   rÇ   r@  Zf_polyr€  r~  rÐ  rÉ  rÞ   r{   r}  ri   rÏ  rl   rÎ   ô  s:    *,

" 
($

rÎ   ztuple[Expr, Symbol]c                 C  sr  | \}}t |tƒ�rn|jd |k�rn|jtkr8t||ƒS |jtkrLt||ƒS tdƒ}|jt	kr˜t|ƒt|ƒ }t
|||t|||t|ƒtd| ||ƒƒƒS |jtkrÜt|ƒt|ƒ }t
|||t|||t|ƒtd| ||ƒƒƒS | t	¡}|jtk�r4t
|||t|||t	|d ƒtd|d d  |tdƒtjtjƒƒƒS |jtk�rnt
|||t|||t	|d ƒtd| ||ƒƒƒS d S )Nr   r—   rQ   r·   )rÖ   r!   r  rð   r&   r­   r#   r®   r   r'   rÝ   rŽ   r°   r$   rR  r%   rö   r   r†  r"   )rP  rd   r  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´   rn  rµ   r„   c                 S  s
   t | tƒS rh   ©rÖ   r   r<  ri   ri   rl   r#  V  r$  zmake_wilds.<locals>.<lambda>rl  rÇ   c                 S  s
   t | tƒS rh   rÒ  r<  ri   ri   rl   r#  W  r$  )r   )r  r´   rµ   r„   rÇ   ri   ri   rl   Ú
make_wildsR  s
    rÓ  c                 C  s>   t | ƒ\}}}}t||  ƒ| t||  ƒ|  }|||||fS rh   )rÓ  r-   r,   ©r  r´   rµ   r„   rÇ   rz  ri   ri   rl   Úsincos_pattern[  s     rÕ  c                 C  s>   t | ƒ\}}}}t||  ƒ| t||  ƒ|  }|||||fS rh   )rÓ  r.   r1   rÔ  ri   ri   rl   Útansec_patternb  s     rÖ  c                 C  s>   t | ƒ\}}}}t||  ƒ| t||  ƒ|  }|||||fS rh   )rÓ  r/   r0   rÔ  ri   ri   rl   Úcotcsc_patterni  s     r×  c                 C  sD   t d| gd�}t d| gd�}t dƒ}t||  | ƒ| }||||fS )Nr„   rn  rµ   r—  )r   r8   )r  r„   rµ   r—  rz  ri   ri   rl   Úheaviside_patternp  s
    rØ  c                   s   ‡ fdd„}|S )Nc                   s   ˆ | Ž S rh   ri   ©r  ©rð   ri   rl   Ú
uncurry_rlz  s    zuncurry.<locals>.uncurry_rlri   )rð   rÛ  ri   rÚ  rl   Úuncurryy  s    rÜ  c                   s   ‡ fdd„}|S )Nc                   sB   | \}}}}}}ˆ ||||||ƒ}||kr>t |||t||ƒƒS d S rh   )rÝ   rO  )r  r´   rµ   r„   rÇ   rd   r  rÞ   ©rR  ri   rl   Útrig_rewriter_rl  s    z'trig_rewriter.<locals>.trig_rewriter_rlri   )rR  rÞ  ri   rÝ  rl   Útrig_rewriter~  s    rß  c                 C  s   |j o|j o|jo|jS rh   )Úis_evenro  ©r´   rµ   r„   rÇ   rÁ   rË   ri   ri   rl   r#  ‡  s   ÿr#  c                 C  s@   dt d|  | ƒ d |d  dt d| | ƒ d |d   S r  )r,   ©r´   rµ   r„   rÇ   rÁ   r  ri   ri   rl   r#  ‹  s   ÿc                 C  s   |j o|dkS ©NrC  ©rÈ  rá  ri   ri   rl   r#  Ž  r$  c                 C  s<   dt | | ƒd  |d d  t| | ƒ t || ƒ|  S r  )r,   r-   râ  ri   ri   rl   r#  ‘  s   
ÿþc                 C  s   |j o|dkS rã  rä  rá  ri   ri   rl   r#  •  r$  c                 C  s<   dt || ƒd  |d d  t|| ƒ t | | ƒ|  S r  )r-   r,   râ  ri   ri   rl   r#  ˜  s   
ÿþc                 C  s   |j o|dkS ©Nrú   ©rà  rá  ri   ri   rl   r#  œ  r$  c                 C  s@   dt || ƒd  |d d  t|| ƒd  t | | ƒ|  S r  )r.   r1   râ  ri   ri   rl   r#  ž  s   ÿþc                 C  s   |j S rh   rä  rá  ri   ri   rl   r#  ¢  r$  c                 C  s<   t | | ƒd d |d d  t| | ƒ t || ƒ|  S ©Nr·   rQ   )r1   r.   râ  ri   ri   rl   r#  ¤  s   
ÿþc                 C  s   |dko|dkS r¶  ri   rá  ri   ri   rl   r#  ¨  r$  c                 C  s   t | | ƒd d S rç  )r1   râ  ri   ri   rl   r#  ª  r$  c                 C  s   |j o|dkS rå  ræ  rá  ri   ri   rl   r#  ¬  r$  c                 C  s@   dt || ƒd  |d d  t|| ƒd  t | | ƒ|  S r  )r/   r0   râ  ri   ri   rl   r#  ®  s   ÿþc                 C  s   |j S rh   rä  rá  ri   ri   rl   r#  ²  r$  c                 C  s<   t | | ƒd d |d d  t| | ƒ t || ƒ|  S rç  )r0   r/   râ  ri   ri   rl   r#  ´  s   
ÿþc                   s„   | \‰ }t ‡ fdd„ttfD ƒƒr€t|ƒ\}}}}}ˆ  |¡‰ˆsFd S ttttt	t
tiƒt‡fdd„||||fD ƒˆ |g ƒƒS d S )Nc                 3  s   | ]}ˆ   |¡V  qd S rh   rD  rœ  r�  ri   rl   r‹   »  s     z#trig_sincos_rule.<locals>.<genexpr>c                   s   g | ]}ˆ   |tj¡‘qS ri   r‘  rÀ   ru  ri   rl   rä   Æ  s     z$trig_sincos_rule.<locals>.<listcomp>)r�   r-   r,   rÕ  r@  r\  Úsincos_botheven_conditionÚsincos_bothevenÚsincos_sinodd_conditionÚsincos_sinoddÚsincos_cosodd_conditionÚsincos_cosoddrx  ©rP  r  rz  r´   rµ   r„   rÇ   ri   ©rd   r@  rl   Útrig_sincos_rule¸  s(    
   ýÿÿürð  c                   sž   | \‰ }ˆ   dt|ƒ t|ƒi¡‰ 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 )NrQ   c                 3  s   | ]}ˆ   |¡V  qd S rh   rD  rœ  r�  ri   rl   r‹   Ð  s     z#trig_tansec_rule.<locals>.<genexpr>c                   s   g | ]}ˆ   |tj¡‘qS ri   r‘  rÀ   ru  ri   rl   rä   Û  s     z$trig_tansec_rule.<locals>.<listcomp>)r“   r,   r1   r�   r.   rÖ  r@  r\  Útansec_tanodd_conditionÚtansec_tanoddÚtansec_seceven_conditionÚtansec_secevenÚtan_tansquared_conditionÚtan_tansquaredrx  rî  ri   rï  rl   Útrig_tansec_ruleÉ  s0    
 ÿ
   ýÿÿür÷  c              	     s¾   | \‰ }ˆ   dt|ƒ t|ƒdt|ƒ t|ƒt|ƒt|ƒ t|ƒi¡‰ t‡ fdd„ttfD ƒƒrºt|ƒ\}}}}}ˆ  |¡‰ˆs„d S t	t
tttiƒt‡fdd„||||fD ƒˆ |g ƒƒS d S )NrQ   c                 3  s   | ]}ˆ   |¡V  qd S rh   rD  rœ  r�  ri   rl   r‹   æ  s     z#trig_cotcsc_rule.<locals>.<genexpr>c                   s   g | ]}ˆ   |tj¡‘qS ri   r‘  rÀ   ru  ri   rl   rä   ð  s     z$trig_cotcsc_rule.<locals>.<listcomp>)r“   r-   r0   r.   r/   r,   r�   r×  r@  r\  Úcotcsc_cotodd_conditionÚcotcsc_cotoddÚcotcsc_csceven_conditionÚcotcsc_cscevenrx  rî  ri   rï  rl   Útrig_cotcsc_ruleÞ  s4    
 
  ý
  þÿÿýrü  c                 C  sj   | \}}t dtd| ƒgd�}| td| ƒ| ¡}|rfdt|ƒ t|ƒ td| ƒ }t|| |ƒS d S )Nr´   r·   rn  )r   r-   r@  r,   rO  )rP  rd   r  r´   r@  Z
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ý  ra  ri   ri   rl   Útrig_powers_products_ruleû  s    ýýrþ  c              	   C  sb  | \}}t dd|gd�}t dd|gd�}tdƒ}|||d   }| |¡}|D �]}| |¡}	|	 |tj¡}
|	 |tj¡}|
jrˆ|
dkpŒ|
j}|jrœ|dkp |j}|
jr°|
dk p´|
j	}|jrÄ|dk pÈ|j	}d }|rô|rôt
|
ƒt
|ƒ t|ƒ }d}n~|�r4|�r4t
|
ƒt
| ƒ }|t|ƒ }t|| k||k ƒ}n>|�rr|�rrt
|
 ƒt
|ƒ }|t|ƒ }t|| k||k ƒ}|rNi }ttttttfD ]:}||ƒ|t
||ƒd ƒ< d||ƒ |t
||ƒd	 ƒ< �qŠ| ||¡ ¡ }t||ƒ}| |¡sN|t||ƒ9 }| ¡ }| dt|ƒ ¡}|�r2| dt|ƒ t|ƒi¡}t||ƒ}| ¡ sNt|||||||ƒ  S qNd S )
Nr´   r   rn  rµ   rï   r·   TrQ   r¼   )r   r   rò   r@  rg  r   rü   Z	is_numberr”  Zis_negativer)   r.   r-   rS   r1   r,   r0   r/   r“   ró   r+  rE  r  r±  rO  ro   rî   )rP  rd   r  rÌ  rÍ  rï   Ztarget_patternÚmatchesrÚ   r@  r´   rµ   Z
a_positiveZ
b_positiveZ
a_negativeZ
b_negativeZx_funcrñ   ry   Úsubstitutionsr   ZreplacedZsecantsr{   ri   ri   rl   Útrig_substitution_rule  sn    


  ÿ 


 ÿ
    ÿr  c           	      C  st   | \}}t |ƒ\}}}}| |¡}|rpd|| krpt|| |ƒ}|| ||  }}t|||| | | | |ƒS d S rÑ   )rØ  r@  rO  rç   )	rP  rd   r  rz  r„   rµ   r—  r@  r{   ri   ri   rl   Úheaviside_rule=  s    
r  c           
      C  sÒ   | \}}t |jƒdkrtj}n
|jd }|jr6|dk r:d S td|gd�td|dgd� }}|jd  |||  ¡}|szd S || ||  }}t|dƒ}|tjkr¦d }nt	t
||ƒ|ƒ}t|||||ƒ}	t||	|ƒS )NrQ   r   r´   rn  rµ   )r¿   r  r   rü   r;  r   r@  r   r�  rv   r9   rê   r‚  )
rP  rd   r¹   rÇ   r´   rµ   r@  r€  r~  r}  ri   ri   rl   Údirac_delta_ruleH  s"    
 

r  c              	   C  sl  | \}}t dƒ}t|||ƒ}d}|�rhtdƒ g }|D �]\}}}	t|	|ƒ}
|d }td ||
¡ƒ |
 ¡ rnq6t|d ƒdk�r(| ¡ \}}|
r¤t||	 |||	|
ƒ}
|j	�r(g }g }t
|tƒrÆ|j}n
| |¡ |D ]8}t|jƒsÔtt||dƒ|ƒ}|rÔ| |t|dƒf¡ qÔ| |
df¡ t|	||ƒ}
| t|||||
ƒ¡ q6t|ƒdk�rZt|||ƒS |�rh|d S d S )Nr—   r   zList of Substitution RulesrQ   r]  T)r   rN  rb   rO  r/  ro   r[   r4  rx   r?  rÖ   r   r  r¡   r   rc  r+  r   rà   rŽ   r¿   rÏ   )rP  rd   r  r�   r   rÜ   Zwaysr�   r¶   r7  Zsubrulerå   rô   Z	piecewiseZcould_be_zerorÚ   r{   ri   ri   rl   Úsubstitution_rule^  sL    



þr  c                 C  s   |   ¡ S rh   )r2  r�  ri   ri   rl   r#  ’  r$  c                 C  s
   |   |¡S rh   )Zapartr�  ri   ri   rl   r#  “  r$  c                 C  s   dS rÓ   ri   r�  ri   ri   rl   r#  ˜  r$  c                 C  s   |   ¡ S rh   )r0  r�  ri   ri   rl   r#  ™  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¦  r  r  ri   rl   r‹   �  s     z<lambda>.<locals>.<genexpr>)rÖ   r   r   r§  r  r�  ri   r  rl   r#  œ  s    c                 C  s   |   ¡ S rh   ©Úexpandr�  ri   ri   rl   r#  ž  r$  c                 C  s   t dd„ |  t¡D ƒƒdkS )Nc                 S  s   h | ]}|j d  ’qS )r   rÙ  r¥  ri   ri   rl   r…  £  s     z<lambda>.<locals>.<setcomp>rQ   )r¿   Zatomsr+   r�  ri   ri   rl   r#  ¢  s    c                 C  s   | j dd�S )NT)Ztrigr  r�  ri   ri   rl   r#  ¤  r$  c                 C  sP   | d }|j }|j}|j}| j|krD| j|kr6t| Ž S t|| jƒS nt| Ž S d S rÑ   )Ú	variablesrÚ   r?  r  rÔ   rÒ   rv   )rP  rd   Zdiff_variablesZundifferentiated_functionZintegrand_variablesri   ri   rl   Úderivative_rule¦  s    

r  c                 C  sJ   | \}}|  dt|ƒ ¡rF| dt|ƒ t|ƒ¡}t|||t||ƒƒS d S rÕ   )r@  r,   r“   r1   rÝ   rO  )rP  rd   r  rÞ   ri   ri   rl   Úrewrites_rule´  s    r	  c                 C  s   t | Ž S rh   )rÒ   ra  ri   ri   rl   Úfallback_rule»  s    r
  zdict[Expr, Expr | None]Ú_integral_cachezdict[Expr, int]r³  Úzc                   sv  |   ˆti¡}|tkrBt| dkr,t| ˆƒS t|   tˆ¡ˆfS n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*ft+žŽ 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krtS tttfD ]}t||ƒr|  S qt|ƒS rh   )rd   r?  r   r   r+   rO   rÖ   Útype)rP  rd   rž  r  ri   rl   rX    s    


zintegral_steps.<locals>.keyc                    s   ‡‡ fdd„}|S )Nc                   s   ˆ | ƒ}|ot |ˆƒS rh   )Ú
issubclass)rP  r–  )rX  Úklassesri   rl   Ú_integral_is_subclass  s    zKintegral_steps.<locals>.integral_is_subclass.<locals>._integral_is_subclassri   )r  r  )rX  )r  rl   Úintegral_is_subclass  s    z,integral_steps.<locals>.integral_is_subclass)3r±  r²  r  rÒ   rÆ   r^   r_   r|  r]   r   rd  rÅ   r’  r¿  r   r   rf  r   r˜  r   rš  r¸  r  rÎ   r   r  r+   r·  r8   r9   r  rO   ri  r   rb  rÑ  rÐ   r	  r  r`   Úpartial_fractions_ruleÚcancel_ruler    rG  rµ  Údistribute_expand_rulerþ  Útrig_expand_ruler�  r  r
  )rd   r  Úoptionsr´  rP  r  r”   ri   )rX  r  rl   rO  Å  s¢    -
ÿ

 þ     ý      ðþþÿýþïéÓ-Ó.rO  c                 C  sŠ   t | |ƒ ¡ }t ¡  t|tƒr†t|jƒdkr†|jd d }t|tƒr†|jd d dkr†| 	|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)rO  rm   r³  ÚclearrÖ   r*   r¿   r  r   rð   r   )r   rÛ   r”   rã   ri   ri   rl   ÚmanualintegrateC  s    1þr  N)T)T(  ru   Ú
__future__r   Útypingr   r   r   r   Úabcr   r   Údataclassesr	   Úcollectionsr
   Úcollections.abcr   Zsympy.core.addr   Zsympy.core.cacher   Zsympy.core.containersr   Zsympy.core.exprr   Zsympy.core.functionr   Zsympy.core.logicr   Zsympy.core.mulr   Zsympy.core.numbersr   r   r   Zsympy.core.powerr   Zsympy.core.relationalr   r   r   Zsympy.core.singletonr   Zsympy.core.symbolr   r   r   Z$sympy.functions.elementary.complexesr   Z&sympy.functions.elementary.exponentialr   r    Z%sympy.functions.elementary.hyperbolicr!   r"   r#   r$   r%   r&   r'   r(   Z(sympy.functions.elementary.miscellaneousr)   Z$sympy.functions.elementary.piecewiser*   Z(sympy.functions.elementary.trigonometricr+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   Z'sympy.functions.special.delta_functionsr8   r9   Z'sympy.functions.special.error_functionsr:   r;   r<   r=   r>   r?   r@   rA   rB   rC   Z'sympy.functions.special.gamma_functionsrD   Z*sympy.functions.special.elliptic_integralsrE   rF   Z#sympy.functions.special.polynomialsrG   rH   rI   rJ   rK   rL   rM   rN   rO   Z&sympy.functions.special.zeta_functionsrP   Z	integralsrR   Zsympy.logic.boolalgrS   Zsympy.ntheory.factor_rT   Zsympy.polys.polytoolsrU   rV   rW   rX   Zsympy.simplify.radsimprY   Zsympy.simplify.simplifyr[   Zsympy.solvers.solversr\   Zsympy.strategies.corer]   r^   r_   r`   Zsympy.utilities.iterablesra   Zsympy.utilities.miscrb   rc   rt   rv   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  r  r  r	  r
  r  r  r  r  r  r  r  r  r  r  rÆ   r  r+  rG  rN  rT  rW  r\  rÐ   rb  rd  rf  ri  rj  rs   rw  rv  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þ  r  r  r  r  r  r  r  r  r  r	  r
  r  Úintr³  r²  rO  r  ri   ri   ri   rl   Ú<module>   s  (<0,	#	2		!W+5L_?M,C




ÿÿÿÿÿÿÿÿÿ<3þüýü~