o o hai@sdZddlmZmZmZddlmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZddlmZmZddlmZddlmZmZmZdd lmZmZmZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>ddl?m@Z@ddlAmBZBddlCmDZDddlEmFZFddlGmHZHddlImJZJddlKmLZLddlMmNZNddlOmPZPddlQmRZRdd lSmTZTmUZUmVZVdd!lWmXZXmYZYmZZZm[Z[d"d#Z\d$d%Z]Gd&d'd'Z^Gd(d)d)Z_Gd*d+d+Z`dMd-d.Zadd,d/e=fd0d1Zbed2Zcd3add3aedd4lfmgZgdNd5d6ZhdOd7d8Zid9d:Zjd;d<Zkd=d>Zld?d@ZmdAdBZndPdCdDZodd3d3e=d/fdEdFZpd/e=fdGdHZqe=fdIdJZrdKdLZsd3S)QzL This module implements Holonomic Functions and various operations on them. )AddMulPow)NaNInfinityNegativeInfinityFloatIpi equal_valued int_valued)S)ordered)DummySymbol)sympify)binomial factorialrf) exp_polarexplog)coshsinh)sqrt)cossinsinc)CiShiSierferfcerfi)gamma)hypermeijerg) meijerint)Matrix) PolyElement) FracElement)QQRR)DMF)roots)Poly) DomainMatrix)sstr)limit)Order) hyperexpand) nsimplify)solve)HolonomicSequenceRecurrenceOperatorRecurrenceOperators)NotPowerSeriesErrorNotHyperSeriesErrorSingularityErrorNotHolonomicErrorcsDfdd}|\}}|jd}|d|f|}||}|S)Ncst|jSN)r0onesdomain)shaperm/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/holonomic/holonomic.py+sz(_find_nonzero_solution..rr7)_solverB transpose)rDhomosysr@ particular nullspacenullitynullpartsolrErCrF_find_nonzero_solution*s   rPcCst||}||jfS)a This function is used to create annihilators using ``Dx``. Explanation =========== Returns an Algebra of Differential Operators also called Weyl Algebra and the operator for differentiation i.e. the ``Dx`` operator. Parameters ========== base: Base polynomial ring for the algebra. The base polynomial ring is the ring of polynomials in :math:`x` that will appear as coefficients in the operators. generator: Generator of the algebra which can be either a noncommutative ``Symbol`` or a string. e.g. "Dx" or "D". Examples ======== >>> from sympy import ZZ >>> from sympy.abc import x >>> from sympy.holonomic.holonomic import DifferentialOperators >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx') >>> R Univariate Differential Operator Algebra in intermediate Dx over the base ring ZZ[x] >>> Dx*x (1) + (x)*Dx )DifferentialOperatorAlgebraderivative_operator)base generatorringrErErFDifferentialOperators4s " rVc@s,eZdZdZddZddZeZddZdS) rQa An Ore Algebra is a set of noncommutative polynomials in the intermediate ``Dx`` and coefficients in a base polynomial ring :math:`A`. It follows the commutation rule: .. math :: Dxa = \sigma(a)Dx + \delta(a) for :math:`a \subset A`. Where :math:`\sigma: A \Rightarrow A` is an endomorphism and :math:`\delta: A \rightarrow A` is a skew-derivation i.e. :math:`\delta(ab) = \delta(a) b + \sigma(a) \delta(b)`. If one takes the sigma as identity map and delta as the standard derivation then it becomes the algebra of Differential Operators also called a Weyl Algebra i.e. an algebra whose elements are Differential Operators. This class represents a Weyl Algebra and serves as the parent ring for Differential Operators. Examples ======== >>> from sympy import ZZ >>> from sympy import symbols >>> from sympy.holonomic.holonomic import DifferentialOperators >>> x = symbols('x') >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx') >>> R Univariate Differential Operator Algebra in intermediate Dx over the base ring ZZ[x] See Also ======== DifferentialOperator cCsh||_t|j|jg||_|durtddd|_dSt|tr(t|dd|_dSt|tr2||_dSdS)NDxF) commutative) rSDifferentialOperatorzeroonerRr gen_symbol isinstancestr)selfrSrTrErErF__init__s    z$DifferentialOperatorAlgebra.__init__cCs dt|jd|j}|S)Nz9Univariate Differential Operator Algebra in intermediate z over the base ring )r1r\rS__str__)r_stringrErErFrasz#DifferentialOperatorAlgebra.__str__cCs|j|jko |j|jkSr?)rSr\r_otherrErErF__eq__s  z"DifferentialOperatorAlgebra.__eq__N)__name__ __module__ __qualname____doc__r`ra__repr__rerErErErFrQZs & rQc@s|eZdZdZdZddZddZddZd d ZeZ d d Z d dZ ddZ ddZ ddZddZeZddZddZdS)rYa Differential Operators are elements of Weyl Algebra. The Operators are defined by a list of polynomials in the base ring and the parent ring of the Operator i.e. the algebra it belongs to. Explanation =========== Takes a list of polynomials for each power of ``Dx`` and the parent ring which must be an instance of DifferentialOperatorAlgebra. A Differential Operator can be created easily using the operator ``Dx``. See examples below. Examples ======== >>> from sympy.holonomic.holonomic import DifferentialOperator, DifferentialOperators >>> from sympy import ZZ >>> from sympy import symbols >>> x = symbols('x') >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx') >>> DifferentialOperator([0, 1, x**2], R) (1)*Dx + (x**2)*Dx**2 >>> (x*Dx*x + 1 - Dx**2)**2 (2*x**2 + 2*x + 1) + (4*x**3 + 2*x**2 - 4)*Dx + (x**4 - 6*x - 2)*Dx**2 + (-2*x**2)*Dx**3 + (1)*Dx**4 See Also ======== DifferentialOperatorAlgebra cCs||_|jj}t|jdtr|jdn|jdd|_t|D]\}}t||js4|t |||<q || |||<q ||_ t |j d|_ dS)z Parameters ========== list_of_poly: List of polynomials belonging to the base ring of the algebra. parent: Parent algebra of the operator. rr7N)parentrSr]gensrx enumeratedtype from_sympyrto_sympy listofpolylenorder)r_ list_of_polyrlrSijrErErFr`s * zDifferentialOperator.__init__csj}t|tr |j}nt|jjjr|g}n jjt|g}dd}||d|}fdd}tdt |D]}||}t |||||}q:t|jS)z Multiplies two DifferentialOperator and returns another DifferentialOperator instance using the commutation rule Dx*a = a*Dx + a' cs&t|trfdd|DS|gS)Ncsg|]}|qSrErE.0rwbrErF zIDifferentialOperator.__mul__.._mul_dmp_diffop..)r]list)r| listofotherrEr{rF_mul_dmp_diffops  z5DifferentialOperator.__mul__.._mul_dmp_diffoprcstjjjg}g}t|tr|D]}||||qn|jj||jj|t||Sr?) rlrSrZr]rappenddiffrq _add_lists)r|sol1sol2rwr_rErF _mul_Dxi_bs    z0DifferentialOperator.__mul__.._mul_Dxi_br7) rsr]rYrlrSrprqrrangertr)r_rd listofselfrrrOrrwrErrF__mul__s   zDifferentialOperator.__mul__csPtts&t|jjjs|jjtfdd|jD}t||jSdS)Ncsg|]}|qSrErErzrxrdrErFr}r~z1DifferentialOperator.__rmul__..)r]rYrlrSrprqrrs)r_rdrOrErrF__rmul__s  zDifferentialOperator.__rmul__cCst|trt|j|j}t||jS|j}t||jjjs(|jjt|g}n|g}|d|dg|dd}t||jS)Nrr7) r]rYrrsrlrSrprqr)r_rdrO list_self list_otherrErErF__add__s   zDifferentialOperator.__add__cCs |d|SNrErcrErErF__sub__) zDifferentialOperator.__sub__cCs d||SrrErcrErErF__rsub__,rzDifferentialOperator.__rsub__cCd|SrrErrErErF__neg__/zDifferentialOperator.__neg__cC|tj|Sr?r OnercrErErF __truediv__2z DifferentialOperator.__truediv__cCs|dkr|St|jjjg|j}|dkr|S|j|jjjkr2|jjjg||jjjg}t||jS|} |dr=||9}|dL}|sF |S||9}q5)Nr7rT)rYrlrSr[rsrRrZ)r_nresultrOrnrErErF__pow__5s$ zDifferentialOperator.__pow__cCs|j}d}t|D]O\}}||jjjkrq |jj|}|dkr+|dt|d7}q |r1|d7}|dkrD|dt|d|jj7}q |dt|dd|jjt|7}q |S) Nr()z + r7z)*%sz*%s**)rsrorlrSrZrrr1r\)r_rs print_strrwrxrErErFraIs *zDifferentialOperator.__str__csPt|trj|jkoj|jkSjd|ko'tfddjddDS)Nrc3s|] }|jjjuVqdSr?rlrSrZryrrErF iz.DifferentialOperator.__eq__..r7)r]rYrsrlallrcrErrFreds   zDifferentialOperator.__eq__cCs$|jj}|t||jd|jvS)zH Checks if the differential equation is singular at x0. r)rlrSr.rrrsrn)r_x0rSrErErF is_singularksz DifferentialOperator.is_singularN)rfrgrhri _op_priorityr`rrr__radd__rrrrrrarjrerrErErErFrYs"#.  rYc@seZdZdZdZdDddZddZeZd d Zd d Z d dZ ddZ ddZ dEddZ ddZddZddZeZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)ZdFd+d,ZdFd-d.ZdGd0d1Zd2d3ZdHd6d7Zd8d9Zd:d;ZdIdd?Z!dJd@dAZ"dBdCZ#dS)KHolonomicFunctiona A Holonomic Function is a solution to a linear homogeneous ordinary differential equation with polynomial coefficients. This differential equation can also be represented by an annihilator i.e. a Differential Operator ``L`` such that :math:`L.f = 0`. For uniqueness of these functions, initial conditions can also be provided along with the annihilator. Explanation =========== Holonomic functions have closure properties and thus forms a ring. Given two Holonomic Functions f and g, their sum, product, integral and derivative is also a Holonomic Function. For ordinary points initial condition should be a vector of values of the derivatives i.e. :math:`[y(x_0), y'(x_0), y''(x_0) ... ]`. For regular singular points initial conditions can also be provided in this format: :math:`{s0: [C_0, C_1, ...], s1: [C^1_0, C^1_1, ...], ...}` where s0, s1, ... are the roots of indicial equation and vectors :math:`[C_0, C_1, ...], [C^0_0, C^0_1, ...], ...` are the corresponding initial terms of the associated power series. See Examples below. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import QQ >>> from sympy import symbols, S >>> x = symbols('x') >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx') >>> p = HolonomicFunction(Dx - 1, x, 0, [1]) # e^x >>> q = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]) # sin(x) >>> p + q # annihilator of e^x + sin(x) HolonomicFunction((-1) + (1)*Dx + (-1)*Dx**2 + (1)*Dx**3, x, 0, [1, 2, 1]) >>> p * q # annihilator of e^x * sin(x) HolonomicFunction((2) + (-2)*Dx + (1)*Dx**2, x, 0, [0, 1]) An example of initial conditions for regular singular points, the indicial equation has only one root `1/2`. >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}) HolonomicFunction((-1/2) + (x)*Dx, x, 0, {1/2: [1]}) >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_expr() sqrt(x) To plot a Holonomic Function, one can use `.evalf()` for numerical computation. Here's an example on `sin(x)**2/x` using numpy and matplotlib. >>> import sympy.holonomic # doctest: +SKIP >>> from sympy import var, sin # doctest: +SKIP >>> import matplotlib.pyplot as plt # doctest: +SKIP >>> import numpy as np # doctest: +SKIP >>> var("x") # doctest: +SKIP >>> r = np.linspace(1, 5, 100) # doctest: +SKIP >>> y = sympy.holonomic.expr_to_holonomic(sin(x)**2/x, x0=1).evalf(r) # doctest: +SKIP >>> plt.plot(r, y, label="holonomic function") # doctest: +SKIP >>> plt.show() # doctest: +SKIP rkrNcCs||_||_||_||_dS)ap Parameters ========== annihilator: Annihilator of the Holonomic Function, represented by a `DifferentialOperator` object. x: Variable of the function. x0: The point at which initial conditions are stored. Generally an integer. y0: The initial condition. The proper format for the initial condition is described in class docstring. To make the function unique, length of the vector `y0` should be equal to or greater than the order of differential equation. N)y0r annihilatorrn)r_rrnrrrErErFr`s zHolonomicFunction.__init__cCsP|rdt|jt|jt|jt|jf}|Sdt|jt|jf}|S)Nz!HolonomicFunction(%s, %s, %s, %s)zHolonomicFunction(%s, %s))_have_init_condr^rr1rnrr)r_str_solrErErFras  zHolonomicFunction.__str__c s|jjj|jjjj}j}kr||fS|||j}t|t|jjj \}}fdd|jj D}fdd|jj D}t ||}t ||}t ||j|j |j}t ||j|j |j}||fS)z^ Unifies the base polynomial ring of a given two Holonomic Functions. cg|]}|qSrErrry)R1rErFr}z+HolonomicFunction.unify..crrErry)R2rErFr}r)rrlrSdomunify old_poly_ringrnrVr^r\rsrYrrr) r_rddom1dom2R newparent_rrrE)rrrFrs    zHolonomicFunction.unifycCs$t|jtrdSt|jtrdSdS)z Returns True if the function have singular initial condition in the dictionary format. Returns False if the function have ordinary initial condition in the list format. Returns None for all other cases. TFN)r]rdictrrrErErFis_singularicss  z HolonomicFunction.is_singularicscCs t|jS)z@ Checks if the function have initial condition. )boolrrrErErFrs z!HolonomicFunction._have_init_condcst|jd|j}t|jdkr>tkr@dkrBttjg}|fddt|D7}t|j|j |j |SdSdSdS)zP Converts a singular initial condition to ordinary if possible. rr7cs g|] \}}|t|qSrErrzrwrxarErFr}  z9HolonomicFunction._singularics_to_ord..N) rrrtintr Zerororrrnr)r_r|rrErrF_singularics_to_ords "  z%HolonomicFunction._singularics_to_ordcCs|jjj|jjjkr||\}}||S|jj}|jj}t||}|jjj}|}|jg} |jg} |jjj} t||D] } | | d} | | q>t||D] } | | d}| |qR| | }g}|D]-}g}t|dD]} | t |j kr| |j qr| | |j | qr| |qht|t ||df|}t|ddf|}t||}|jr'|d7}| | d} | | | | d}| || | }g}|D]-}g}t|dD]} | t |j kr| |j q| | |j | q| |qt|t ||df|}t|ddf|}t||}|js|d|d|}t||jj}||j}t|j |jjdd}|rS|sYt||jS|dkr|dkr|j|jkrt||j}t||j}ddt||D}t||j|j|S|jd}|jd}|jdkr|s|s||dS|jdkr|s|s|d|S|j|j}|j|j}|s|s|||jS||j|S|j|jkrt||jSd}d}|dkr|dkrd dt|j D}t!j"|i}|j }n5|dkr6|dkr6d dt|j D}|j }t!j"|i}n|dkrJ|dkrJ|j }|j }i}|D] } | |vrgd dt|| || D|| <qN|| || <qN|D]} | |vr~|| || <qqt||j|j|S) Nrr7FnegativecSg|]\}}||qSrErErzrr|rErErFr}z-HolonomicFunction.__add__..rTcSg|] \}}|t|qSrErrrErErFr}cSrrErrrErErFr}rcSrrErErrErErFr}r)#rrlrSrrumax get_fieldrRrrrtrsrZnewto_listr0rIzerosrPis_zero_matrixflat _normalizerrrnrr _extend_y0zipr change_icsrorr r)r_rdrr|deg1deg2dimrKrowsself rowsothergenrwdiff1diff2rowrDexprprJrOry1y2rselfat0otherat0selfatx0 otheratx0_y0rErErFr$s                          $  zHolonomicFunction.__add__Fc Cs<|jjj}|dkro|}|r|j||dSi}|jD]<}|j|}g}t|D](\} } | dkr9|t j q*|| ddkrEt d|| t || dq*|||d<qt |drct dt |j||j|j|S|s|rt |j||j|jt j gSt |j||jSt |drt|dkr|d|jkr|j} |d} |d } d}nd }t j g}||j7}t |j||j|j|}|s|S| | kr>z|}Wn ttfyd }Ynw|r||j| }t|tr||j| }n|| }| |jkr|d||d<t |j||j| |St | jr>|r5||j| }t|tr1||j| }||S|| }||S| |jkrOt |j||j| |St | jrz%t |j||j| |}||j| }t|tss|WS||j| WSttfyt |j||j| || YSwt |j||jS) az Integrates the given holonomic function. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import QQ >>> from sympy import symbols >>> x = symbols('x') >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx') >>> HolonomicFunction(Dx - 1, x, 0, [1]).integrate((x, 0, x)) # e^x - 1 HolonomicFunction((-1)*Dx + (1)*Dx**2, x, 0, [0, 1]) >>> HolonomicFunction(Dx**2 + 1, x, 0, [1, 0]).integrate((x, 0, x)) HolonomicFunction((1)*Dx + (1)*Dx**3, x, 0, [0, 1, 0]) T)initcondrr7z1logarithmic terms in the series are not supported__iter__z4Definite integration for singular initial conditionsrFN)rrlrRrr integraterrorr rNotImplementedErrorhasattrrrnrrrtto_exprr<r;subsr]rr2evalf is_Number)r_limitsrDrDrrwcc2rxcjrrr|definiteindefinite_integralindefinite_exprloweruppers indefiniterErErFrs                   zHolonomicFunction.integratec s|dd|r,|d|jkrtjSt|dkr,|}t|dD] }||d}q |S|j}|jd|j j j krA|j dkrAtjS|jd|j j j krzt |jdd|j }|rt|dkrnt||j|j|jddSt||jSt||jS|j j }|fdd |jDfd d ddD}|dj t|}t|j jg}t|dd|jj dd }|r|dkrt||jSt||j ddd}t||j|j|S) aK Differentiation of the given Holonomic function. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import ZZ >>> from sympy import symbols >>> x = symbols('x') >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx') >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).diff().to_expr() cos(x) >>> HolonomicFunction(Dx - 2, x, 0, [1]).diff().to_expr() 2*exp(2*x) See Also ======== integrate evaluateTrrr7NFcg|] }|qSrErrryrrErFr}mz*HolonomicFunction.diff..csg|]}|dqSrrEry)seq_dmfrErFr}prr) setdefaultrnr rrtrrrrsrlrSrZrurYrrrrrrinsert_derivate_diff_eqrr[rr) r_argskwargsrOrwannrrhsrrE)rr rFr4s>       zHolonomicFunction.diffcCsH|j|jks |j|jkrdS|r"|r"|j|jko!|j|jkSdS)NFT)rrnrrrrcrErErFres zHolonomicFunction.__eq__cs j}tts5t jrtd s St |j } fdd|D t| j j S jj j jj j krJ \Sj}|j |j |j j }|fdd|jDfdd|jDfddtD}fddtD}fddtd Djd d <fd dtDg}t|d f} td f} t| | } | jrtd d d D]Ttd d d D]Id 7<d 7<tjrt<qڈ j<qqtd D].jr7q+tD]|7<q;j<q+tD]/d krkq^tD]|7<qoj<q^|fd dtDt|t|f} t| | } | jst|  jj dd} rȈst| jS dkrÈ dkrÈ j j krmt | j } t| j }| d |d g}td t!t| t|D]_fddtd D}td D]td D]}|kr3t"||<q!qd } td D]td D]}| ||| ||7} qGq?|| qt| j j |S j#d }j#d } j d kr|s|s $d Sj d kr|s|s $d S j# j }j# j }|s|s $ j S $j S j j krt| jSd d dkr dkrddt% j&D}t'j(|i j& n5 dkr dkrddt%j&D} j& t'j(|i n dkr* dkr* j& j& i} D]E D]?t!t t } fddt|D}|vr^||<q2ddt)||D|<q2q.t| j j |S)Nz> Can't multiply a HolonomicFunction and expressions/functions.cs g|] }t|jjqSrE)r/rrnrepr)rdr_rErFr}rz-HolonomicFunction.__mul__..crrEr rr rErFr}r crrEr rr rErFr}r cg|] }| qSrErEry)rrrErFr}crrErEry)r|rrErFr}rcs&g|]}fddtdDqS)csg|]}jqSrE)rZryr rErFr}8HolonomicFunction.__mul__...r7rr)rr|rErFr}&r7rc&g|]}tD]}||qqSrErrr| coeff_mulrErFr}rrcrrErrrrErFr}rFrcs"g|] }ddtdDqS)cSsg|]}dqSr rEryrErErFr}srr7rr)rwrErFr}s"TcSrrErrrErErFr}rcSrrErrrErErFr}rcs8g|]tfddtdDtjdqS)c3s,|]}||VqdSr?rE)rzr|)rrwrxrrrErFr!s*z7HolonomicFunction.__mul__...r7start)sumrr r)rz)rwrxrrrrFr}!s " cSrrErErrErErFr}&r)*rr]rrhasrnrrrrurrlrSrrrsrr[r0rIrrPrrpDMFdiffris_zerorZrrtrrrminrrrrorr rr)r_rdann_selfr ann_otherrself_red other_redlin_sys_elementslin_syshomo_sysrOsol_anny0_selfy0_othercoeffkrrrrrrrE) rrr|rrwrxrrrdr_rrrFrs        (  ( !   $      (zHolonomicFunction.__mul__cCs ||dSrrErcrErErFr+rzHolonomicFunction.__sub__cCs |d|SrrErcrErErFr.rzHolonomicFunction.__rsub__cCrrrErrErErFr1rzHolonomicFunction.__neg__cCrr?rrcrErErFr4rzHolonomicFunction.__truediv__c s|jjdkrK|j}|j|jdurd}n t|jd|g}|jd}|jd}t||j|j }fdd||fD}t |}t ||j|j |S|dkrSt d|jjj}t ||jtjtjg} |dkri| S|} |drt| | 9} |dL}|s} | S| | 9} ql)Nr7rcsg|]}j|qSrE)rSrrryrlrErFr}Frz-HolonomicFunction.__pow__..z&Negative Power on a Holonomic FunctionTr)rrurlrrrsr/rrnrrYrrr>rRr rr) r_rrrp0p1rOddrWrrnrEr2rFr7s8      zHolonomicFunction.__pow__cCstdd|jjDS)zF Returns the highest power of `x` in the annihilator. cs|]}|VqdSr?degreeryrErErFr]z+HolonomicFunction.degree..)rrrsrrErErFr8YszHolonomicFunction.degreecsjj}jj}j}jjtD]\}}t|jjjj r-jjj ||<q| jifddt |D} ddt |D} t j| d<| g} tddt |Dg} fdd| D} t |dD]}| |d| ||7<qut |D]}| || d | ||7<q| } | | t| | \}}|jdurnqft|d}| |d}t|dd |d d }|rt|j|d|dSt|jS) a` Returns function after composition of a holonomic function with an algebraic function. The method cannot compute initial conditions for the result by itself, so they can be also be provided. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import QQ >>> from sympy import symbols >>> x = symbols('x') >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx') >>> HolonomicFunction(Dx - 1, x).composition(x**2, 0, [1]) # e^(x**2) HolonomicFunction((-2*x) + (1)*Dx, x, 0, [1]) >>> HolonomicFunction(Dx**2 + 1, x).composition(x**2 - 1, 1, [1, 0]) HolonomicFunction((4*x**3) + (-1)*Dx + (x)*Dx**2, x, 1, [1, 0]) See Also ======== from_hyper cs&g|]}|ji qSrE)rrnryrrsrDr_rErFr}rz1HolonomicFunction.composition..cSg|]}tjqSrEr rryrErErFr}rrcSr;rEr<ryrErErFr}rTcsg|]}|jqSrE)rrn)rzrrrErFr}rr7rNFr)rrlrurrnrsror]rSrprrrrr rr(rIrgauss_jordan_solverrrr)r_rrrrrrrwrxrcoeffssystem homogeneous coeffs_nextrOtaustaurEr:rF composition_sD   "      zHolonomicFunction.compositionTc sr|jdkr ||jS|j|jr|j|dSi}tddd|jjjj }t | d\}}t |jj D]W\}}t|d}t|dD]B} ||| } | dkrYqL|| | f|vrz||| | f|| t| d|7<qL|| t| d|||| | f<qLq8g} dd |D} t| t| } |}|}i}g}g}t| dD]$| vrtfd d |Dtjd }| |q| tjqt| |} | j}t|j| j d dd}|}|rt|d}t||}||7}t||}dd t |D}t||kr(t|D]{}tj}|D]m|ddkr|dt|krV||d||d<n$|d|vrztd|d||d<|||dd|kr|| |||d7}q'||q t!|g|R}t"|t#rtt||D])}||vrtd|||<|||vr||||q|||q|rt$| ||fgSt$| |gStt||D]4}||vrtd|||<d}|D]||vr|||d}q|s&|||q|r3t$| ||fgSt$| |gS)aG Finds recurrence relation for the coefficients in the series expansion of the function about :math:`x_0`, where :math:`x_0` is the point at which the initial condition is stored. Explanation =========== If the point :math:`x_0` is ordinary, solution of the form :math:`[(R, n_0)]` is returned. Where :math:`R` is the recurrence relation and :math:`n_0` is the smallest ``n`` for which the recurrence holds true. If the point :math:`x_0` is regular singular, a list of solutions in the format :math:`(R, p, n_0)` is returned, i.e. `[(R, p, n_0), ... ]`. Each tuple in this vector represents a recurrence relation :math:`R` associated with a root of the indicial equation ``p``. Conditions of a different format can also be provided in this case, see the docstring of HolonomicFunction class. If it's not possible to numerically compute a initial condition, it is returned as a symbol :math:`C_j`, denoting the coefficient of :math:`(x - x_0)^j` in the power series about :math:`x_0`. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import QQ >>> from sympy import symbols, S >>> x = symbols('x') >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx') >>> HolonomicFunction(Dx - 1, x, 0, [1]).to_sequence() [(HolonomicSequence((-1) + (n + 1)Sn, n), u(0) = 1, 0)] >>> HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1]).to_sequence() [(HolonomicSequence((n**2) + (n**2 + n)Sn, n), u(0) = 0, u(1) = 1, u(2) = -1/2, 2)] >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_sequence() [(HolonomicSequence((n), n), u(0) = 1, 1/2, 1)] See Also ======== HolonomicFunction.series References ========== .. [1] https://hal.inria.fr/inria-00070025/document .. [2] https://www3.risc.jku.at/publications/download/risc_2244/DIPLFORM.pdf r)lbrTintegerSnr7cSg|]}|dqSr rEryrErErFr}r~z1HolonomicFunction.to_sequence..c30|]\}}|dkr|VqdSrNrrzr1vrxrrrErFr z0HolonomicFunction.to_sequence..rrZfiltercSrrErrrErErFr}rC_%sF)%rshift_x to_sequencerr _frobeniusrrlrSrr:rrors all_coeffsrtrrrrr%rr8r!itemsr rrr9rur.keysrrr6r]rr8)r_rEdict1rrrrw listofdmpr8r1r0rOkeylistr smallest_ndummyseqsunknownstempru all_rootsmax_rootru0eqsoleqsrrErOrFrVs 4     2*        $     zHolonomicFunction.to_sequencec* sd|}g}g}t|D]#}|jr||g||q|\}}||||fg||q|jddd|jddd|g}|D])}t|dkrY||gqJ|D]t d|rl|nq[||gqJt dd|D} t dd|D} t d d|D} | d krg} t|j D]}t|D] t |r| |qqnG| r| rt|g} n=| rd d |Dd d |D} n,| sdd |D} n"| s|rt|j djdkrt|g} n dd |D} t| g} tdd d|jjjj}t|d\}}g}td}| D]}i}t|jjD]g\}}t|d}t|dD]Q}|||}|dkrHq9||||f|vrq|||||f||t|d||7<q9||t|d|||||||f<q9q%g}dd |D}t|t |}t dd|D}tdd|D}|}i}g}g} t|dD]'|vrt!fdd|"Dtj#d}!||!q|tj#qt$||}|j%}"t&|j|jddd}#|#}#|#rt |#d}$t |$|}|"|7}"g}%| d kr$|j |}%n<| dkr`|dkr`t'||kr`t| dkr`t(||"t'|tt'|kr`fdd tt'|tD}%t|%|"krt||D]}tj#}&|D]s|ddkrtj#||d<nD|dt|%kr|%|d||d<n*|d|vrt)|d|d}'t|'||d<| ||dd|kr|&|*|||d7}&qs||&qlt+|g| R}(t,|(t-rOtt|%|"D]/}||vrt)|d|}'t|'||<|||(vr*|%|(||q|%||q|rC|t.||%||fq|t.||%|fqtt|%|"D]:}||vrkt)|d|}'t|'||<d})|(D]||vr|%||d })qo|)s|%||qV|r|t.||%||fn |t.||%|f|d7}q|S) NcS|dS)Nr7rErnrErErFrGjz.HolonomicFunction._frobenius..)keycSrhNrrErirErErFrGkrjrcss|] }t|dkVqdSr7N)rtryrErErFr~sz/HolonomicFunction._frobenius..css|]}|dkVqdSrKrEryrErErFrr9css|]}t|VqdSr?)r ryrErErFrr9TcSrIr rEryrErErFr}r~z0HolonomicFunction._frobenius..cSrIr rErrErErFr}r~cSsg|] }t||ks|qSrErryrErErFr}rFcSsg|]}|dkr|qSr rEryrErErFr}rrrFrHCr7cSrIr rEryrErErFr}r~cs|]}|dVqdSrmrEryrErErFrr9csrprmrEryrErErFrr9c3rJrKrLrMrOrErFrrPrrrQrRcsg|] }|t|qSrErry)rrErFr}rz_%s)/ _indicialrrZis_realextend as_real_imagsortrtrr rrrr r%rr is_finiterrrlrSrr:rordrorsrXrrrrrr!rYrr9rur.rrchrrr6r]rr8)*r_rE indicialrootsrealscomplrwrr|grp independentallposallintrootstoconsiderposrootsrrrfinalsolcharrr[r\r8r1r0rOr]rdegree2r^r_r`rarbrurcrdrerfletterrgrrE)rxrrrrFrW\s$                 <4      4 $      zHolonomicFunction._frobeniusc s|dur }n|}t|trt|dkr|d}dnOt|tr1t|dkr1|d|d}n;t|dkrHt|ddkrH|dd}dn$t|dkrct|ddkrc|dd|dd}n fdd|DS|t}t|jd}|jjjj }|jj }|jj j } | fdd|Dfd dtDt|j|d|krt|d|D]tfd d tDtjd } | q|rوStfd d tDtjd } |r| t|t7} |dkr| |S| S)a Finds the power series expansion of given holonomic function about :math:`x_0`. Explanation =========== A list of series might be returned if :math:`x_0` is a regular point with multiple roots of the indicial equation. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import QQ >>> from sympy import symbols >>> x = symbols('x') >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx') >>> HolonomicFunction(Dx - 1, x, 0, [1]).series() # e^x 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6) >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).series(n=8) # sin(x) x - x**3/6 + x**5/120 - x**7/5040 + O(x**8) See Also ======== HolonomicFunction.to_sequence Nrrrr7csg|]}j|dqS))_recur)seriesryrrErFr}Xrz,HolonomicFunction.series..crrEr rr rErFr}br crrErEry)r1seqrErFr}crc3s6|]}|dkrt||VqdSrK)DMFsubsr)rwrOsubrErFris z+HolonomicFunction.series..rc3s$|] \}}||VqdSr?rEr) constantpowerrnrErFrp")rVr]tuplertrre recurrencerurnrrsrlrSrrrr!r rrror3r) r_r coefficientrurrlrseq_dmprr0serrE) rrrwr1r_rrOrrnrFr(sZ          zHolonomicFunction.seriesc s|jdkr ||jS|jj}|jjj|jj}j }fddt dd|D}dt d|t d|jj fdd t fd dt |D}t |D]1\}}|}t|d}d||kro|kr}nn ||||||}||9}qUt|S) z: Computes roots of the Indicial equation. rcs,t|dd}d|vr|dSdS)NrQrRr)r.rrrZ)polyroot_all)rrnrErF _pole_degrees z1HolonomicFunction._indicial.._pole_degreecsr6r?r7rrErErFrr9z.HolonomicFunction._indicial.. r7cs|jrS|Sr?)r$)q)rinfrErFrGrz-HolonomicFunction._indicial..c3s |] \}}||VqdSr?rE)rzrxr)degrErFrs)rrUrqrrsrlrSrnrZr[rrur%rorXrtrqr.rr) r_ list_coeffryr8r|rwrxr\rE)rrrrrnrFrqxs&   zHolonomicFunction._indicialRK4皙?c Cs ddlm}d}t|dsQd}t|}|j|kr#|||g||ddS|js(t|j}||kr2| }t|||} ||g}t| dD] } | |d|qEt |j j j |j jd|jD]} | |jksl| |vrqt|| qa|r~|||||ddS|||||dS) a Finds numerical value of a holonomic function using numerical methods. (RK4 by default). A set of points (real or complex) must be provided which will be the path for the numerical integration. Explanation =========== The path should be given as a list :math:`[x_1, x_2, \dots x_n]`. The numerical values will be computed at each point in this order :math:`x_1 \rightarrow x_2 \rightarrow x_3 \dots \rightarrow x_n`. Returns values of the function at :math:`x_1, x_2, \dots x_n` in a list. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import QQ >>> from sympy import symbols >>> x = symbols('x') >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx') A straight line on the real axis from (0 to 1) >>> r = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1] Runge-Kutta 4th order on e^x from 0.1 to 1. Exact solution at 1 is 2.71828182845905 >>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r) [1.10517083333333, 1.22140257085069, 1.34985849706254, 1.49182424008069, 1.64872063859684, 1.82211796209193, 2.01375162659678, 2.22553956329232, 2.45960141378007, 2.71827974413517] Euler's method for the same >>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r, method='Euler') [1.1, 1.21, 1.331, 1.4641, 1.61051, 1.771561, 1.9487171, 2.14358881, 2.357947691, 2.5937424601] One can also observe that the value obtained using Runge-Kutta 4th order is much more accurate than Euler's method. r)_evalfFrT)method derivativesrr7)sympy.holonomic.numericalrrr rrrrrrr.rrlrSrrrsrnr=) r_pointsrhrrlpr|rrrwrErErFrs. .   $ zHolonomicFunction.evalfcsV|jjjj}||td\}}fdd|jjD}t||}t|||j |j S)z Changes only the variable of Holonomic Function, for internal purposes. For composition use HolonomicFunction.composition() rWcsg|]}|qSrE)rrrrErFr}rz.HolonomicFunction.change_x..) rrlrSrrrVrsrYrrr)r_zrrlrrOrErrFchange_xs   zHolonomicFunction.change_xcsh|j|jj}|jjjfdd|D}t||jj}|j}|s,t|St|||j S)z- Substitute `x + a` for `x`. c s(g|]}|qSrE)rqrrrryrrSrnrErFr}s(z-HolonomicFunction.shift_x..) rnrrsrlrSrYrrrr)r_rlistaftershiftrOrrErrFrUs   zHolonomicFunction.shift_xc sV|dur |}n|}t|tr!t|dkr!|d}|d}d}nst|tr9t|dkr9|d}|d}|d}n[t|dkrVt|ddkrV|dd}|dd}d}n>t|dkrwt|ddkrw|dd}|dd}|dd}n|j||dd}|ddD] }||j||d7}q|S|j}|j|j} |j} j } | dkr;t j j jd|jdd} tj}t| D]?\} }|dkst|sqt|}|t|krt||ttfr||||<|||| |7}q|td | | |7}qt|ttfr|| |}n|| |}|r,| dkr(|| | | fgS|fgS| dkr9|| | | S|S|| t|krHtd tfd d jdd Dr_t||jjd}jd }t|ttfrt|| | t|| |}nt|| | t|| |}d}t j j ||j}t j j ||j}|rg}t|| D]}||kr|r| t||| ||| | | fn |t||| |7}qt||dkrqg}g}t!|"D]}|#t$||| g||qt!|"D]}|#t$||| g||q+d|vrJ|%dn| d|ry| t||| ||| | | t&|||| | | | | fq|t||t&|||| | | |7}q|r|S|| |}| dkr|| | | S|S)a Returns a hypergeometric function (or linear combination of them) representing the given holonomic function. Explanation =========== Returns an answer of the form: `a_1 \cdot x^{b_1} \cdot{hyper()} + a_2 \cdot x^{b_2} \cdot{hyper()} \dots` This is very useful as one can now use ``hyperexpand`` to find the symbolic expressions/functions. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import ZZ >>> from sympy import symbols >>> x = symbols('x') >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx') >>> # sin(x) >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).to_hyper() x*hyper((), (3/2,), -x**2/4) >>> # exp(x) >>> HolonomicFunction(Dx - 1, x, 0, [1]).to_hyper() hyper((), (), x) See Also ======== from_hyper, from_meijerg Nrr7rr)as_listrrrRrTz+Can't compute sufficient Initial Conditionsc3s|] }|jjjkVqdSr?rryrCrErFrmrz-HolonomicFunction.to_hyper..r)'rVr]rrtto_hyperrerrnrrur.rlrSrrrsrr rror rr)r*as_exprrrranyr<LCr8rrrrZrsr5remover%)r_rrrr^rrOrwrernrm nonzerotermsrxrr|rarg1arg2 listofsolapbqr1rErCrFrs#            "   <2 .$$   N0  zHolonomicFunction.to_hypercCst|S)a_ Converts a Holonomic Function back to elementary functions. Examples ======== >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators >>> from sympy import ZZ >>> from sympy import symbols, S >>> x = symbols('x') >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx') >>> HolonomicFunction(x**2*Dx**2 + x*Dx + (x**2 - 1), x, 0, [0, S(1)/2]).to_expr() besselj(1, x) >>> HolonomicFunction((1 + x)*Dx**3 + Dx**2, x, 0, [1, 1, 1]).to_expr() x*log(x + 1) + log(x + 1) + 1 )r4rsimplifyrrErErFrszHolonomicFunction.to_exprc Csd}|durt|j|jjkrt|j}|jjjj}zt||j |||d}Wn t t fy5d}Ynw|r?|j |kr?|S|j |dd}t|j|j ||S)a Changes the point `x0` to ``b`` for initial conditions. Examples ======== >>> from sympy.holonomic import expr_to_holonomic >>> from sympy import symbols, sin, exp >>> x = symbols('x') >>> expr_to_holonomic(sin(x)).change_ics(1) HolonomicFunction((1) + (1)*Dx**2, x, 1, [sin(1), cos(1)]) >>> expr_to_holonomic(exp(x)).change_ics(2) HolonomicFunction((-1) + (1)*Dx, x, 2, [exp(2)]) TN)rnrlenicsrAF)r)rtrrrurlrSrAexpr_to_holonomicrrnr;r<rrr)r_r|rsymbolicrrOrrErErFrs  zHolonomicFunction.change_icscCs^|jdd}tj}|D]!}t|dkr||d7}q t|dkr,||dt|d7}q |S)a Returns a linear combination of Meijer G-functions. Examples ======== >>> from sympy.holonomic import expr_to_holonomic >>> from sympy import sin, cos, hyperexpand, log, symbols >>> x = symbols('x') >>> hyperexpand(expr_to_holonomic(cos(x) + sin(x)).to_meijerg()) sin(x) + cos(x) >>> hyperexpand(expr_to_holonomic(log(x)).to_meijerg()).simplify() log(x) See Also ======== to_hyper T)rr7rr)rr rrt_hyper_to_meijerg)r_rrOrwrErErF to_meijergs   zHolonomicFunction.to_meijergrKFT)rFTN)rrF)FNr?)$rfrgrhrirr`rarjrrrrrrrrerrrrrrrr8rDrVrWrrqrrrUrrrrrErErErFrtsNB   M"" @ > MP $K 1  #rFcCsf|j}|j}|jd}|t}tt|d\}}||} d} |D]} | | | 9} q$| d} |} |D]}| | |9} q5| | }t |}|t t fvrTt || |Sddd}t|ts|||||j}|sv|d7}|||||j}|rht || |||St|trd}|||||j|}|s|d7}|||||j|}|rt || |||St || |S) a Converts a hypergeometric function to holonomic. ``func`` is the Hypergeometric Function and ``x0`` is the point at which initial conditions are required. Examples ======== >>> from sympy.holonomic.holonomic import from_hyper >>> from sympy import symbols, hyper, S >>> x = symbols('x') >>> from_hyper(hyper([], [S(3)/2], x**2/4)) HolonomicFunction((-x) + (2)*Dx + (x)*Dx**2, x, 1, [sinh(1), -sinh(1) + cosh(1)]) rrWr7FcSfg}t|D]*}|r|||}n|||}|jdus#t|tr&dS||||}q|SNFrrrrvr]rrrsimprnrrurrrwvalrErErF_find_conditions6s    z$from_hyper.._find_conditionsNr)rrratomsrpoprVr+rr4rrrrDr]r%ru)funcrrrr|rrnrrWxDxr1aixDx_1r2birOrrrrErErF from_hypersD     rTcCs|j}|j}t|j}t|j}t|} |jd} | t} t | | d\} } | | }|d}| d||| }|D]}|||9}q>d}|D]}|||9}qK||}|sbt ||  | St |}|ttfvrtt ||  | Sd dd}t|ts||| ||j}|s|d7}||| ||j}|rt ||  | ||St|trd}||| ||j|}|s|d7}||| ||j|}|rt ||  | ||St ||  | S) a Converts a Meijer G-function to Holonomic. ``func`` is the G-Function and ``x0`` is the point at which initial conditions are required. Examples ======== >>> from sympy.holonomic.holonomic import from_meijerg >>> from sympy import symbols, meijerg, S >>> x = symbols('x') >>> from_meijerg(meijerg(([], []), ([S(1)/2], [0]), x**2/4)) HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1/sqrt(pi)]) rrWr7rFcSrrrrrErErFrs    z&from_meijerg.._find_conditionsNr)rrrtanbmrrrrrVrrrDr4rrr]r&ru)rrrrrArr|rrrrrnrrWrxDx1rrrrrOrrrrErErF from_meijerg\sN       rx_1N)_mytypec Cst|}|j}|st|dkr|}n td||vr!||t|}|dur?|tr1t }nt }t|dkr?|| }t |||||||d} | rN| St s[|aia tt |dn|tkri|aia tt |d|jr||t} t| t} | t vrt | } | dd|} n>t||d|d} | st|r|| _|s|s|| _| S|s| jj}t||||}|s|d7}t||||}|rt| j|||S|s|s| |jd} |r|| _|| _| S|s| jj}t||||}|s|d7}t||||}|r| |jd||S|j}|j} t |d|d|d } | t!ur1t"dt|D]}| t |||d|d 7} q n(| t#urNt"dt|D]}| t |||d|d 9} q=n | t$urY| |d} || _| sat|rg|| _|sm|so| S| jru| S|s|| jj}| j%|r| &}t|} t|dkr|| dt'j(kr| d}||||}t||||}d d t)|D}||i}t| j|||St||||}|s|d7}t||||}|rt| j|||S) a Converts a function or an expression to a holonomic function. Parameters ========== func: The expression to be converted. x: variable for the function. x0: point at which initial condition must be computed. y0: One can optionally provide initial condition if the method is not able to do it automatically. lenics: Number of terms in the initial condition. By default it is equal to the order of the annihilator. domain: Ground domain for the polynomials in ``x`` appearing as coefficients in the annihilator. initcond: Set it false if you do not want the initial conditions to be computed. Examples ======== >>> from sympy.holonomic.holonomic import expr_to_holonomic >>> from sympy import sin, exp, symbols >>> x = symbols('x') >>> expr_to_holonomic(sin(x)) HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1]) >>> expr_to_holonomic(exp(x)) HolonomicFunction((-1) + (1)*Dx, x, 0, [1]) See Also ======== sympy.integrals.meijerint._rewrite1, _convert_poly_rat_alg, _create_table r7z%Specify the variable for the functionNr)rrrrAr)rAFrrA)rnrrAcSrrErrrErErFr}H rz%expr_to_holonomic..)*r free_symbolsrtr ValueErrorrrr"rr,r+r_convert_poly_rat_alg _lookup_tabledomain_for_table _create_table is_Functionrrrr_convert_meijerintrrrrrurrrDrrrrrrrrrqr rro)rrnrrrrArsyms extra_symssolpolyftrrOrrrwrDg singular_icsrErErFrs)              "rc Csvg}g}|j}|}|tj}g}t|D]=\} } t| |jr,|| | nt| |js=||t | n|| |||  |||  q|D]} | |}qW|rd| }| | }t|D] \} } | ||| <qo||d |d  } |D]} | | } q| | } t|D]\} } | | } || |  || <qt||S)z' Normalize a given annihilator r)rSrrqr rror]rprrrrnumerdenomlcmgcdrY) list_ofrlrnumrrSr lcm_denom list_of_coeffrwrx gcd_numerfrac_ansrErErFrV s:        rcCshg}t|d}|t|d|t|ddD]\}}|t||||q||||S)a* Let a differential equation a0(x)y(x) + a1(x)y'(x) + ... = 0 where a0, a1,... are polynomials or rational functions. The function returns b0, b1, b2... such that the differential equation b0(x)y(x) + b1(x)y'(x) +... = 0 is formed after differentiating the former equation. r7rN)rtrr#ro)rsrrOrrwrxrErErFr s rc Cs|j}|j}tdd|Drt|S|jd}dd|D}d}tjf}dd|D}tj}|D]} |t| }q1|D]} |t| }q<|t ||||| S)z( Converts a `hyper` to meijerg. css$|] }|dko t||kVqdSrKrnryrErErFr rz$_hyper_to_meijerg..rcs|]}d|VqdSrmrEryrErErFr r9rEcsrrmrEryrErErFr r9) rrrr4rr rrr$r&) rrrrranprbmqr1rwrErErFr s rcCs`t|t|krddt||D|t|d}|Sddt||D|t|d}|S)zvTakes polynomial sequences of two annihilators a and b and returns the list of polynomials of sum of a and b. cSrrErErrErErFr} rz_add_lists..NcSrrErErrErErFr} r)rtr)list1list2rOrErErFr s $$rc sX|j|js |dkr|jS|j}|jg|j}|jj}|}|j D]}t ||jjj r: | |q&t|ksG|t|krI|SfddtD}|dtt|}t|D];} d} t||D]'\} t| |j} t| dds|St | ttfr| } | | 7} qo| | t||}qf||t|dS)zy Tries to find more initial conditions by substituting the initial value point in the differential equation. TcrrErEryrrsrErFr} sz_extend_y0..Nrrv)rrrrrrurlrSrrsr]rprrrrtrr%rrgetattrr)r*rr) Holonomicrrrrrrxlist_redrrrOr|rDrErrFr s<       rcCs\t|ts |S||}||}| |||}|d}|||fSrl)r]r-rrrr)fracrrrsol_num sol_denomrErErFr# s   r#c Cst|ts|S|j}|j}tj}tj}|rddlm}tt |D]\}} |r/t |  |j } || ||7}q!tt |D]\}} |rLt |  |j } || ||7}q>t|t tfr`|}t|t tfrk|}||S)Nr)mp)r]r-rdenr rmpmathrroreversedr _to_mpmathprecr)r*r) rrmpmrrsol_psol_qrrwrxrErErFr s*  rcCs|}|s |}nd}|s4|s4|\} } | r1| jr1t| tr't| } | j| j} } d} nd} nd} |s>|s>| s>dS| |}t |d\}}| |sWt ||d|gS|r||| |}t|j|jdd}||}|dur|dkr|r||}tt|D]\}}|dkrqtt||d}|}t|D]\}}t|ttfr|||<q|t|i}n|r|\}}||||| ||| |}t|j|jdd}nv| rV| || |d}t ||| j}||}|durV|dkrV|rV|dus|dkrV|| }tt|D]#\}}|dkr*qt|ttfr6|}t|| }t|| }t|ttfrO|}|t|gi}|s\|sct ||||S|si|j}||rt |||}t|}t |dkr||dtj!kr|d}||||}t"||||}dd t|D}||i}t ||||St"||||}|s|d7}t"||||}|rt ||||S) zO Converts polynomials, rationals and algebraic functions to holonomic. TFNrWrrr7cSrrErrrErErFr}} rz)_convert_poly_rat_alg..)# is_polynomialis_rational_function as_base_exprr]rr5rrrrVr"rrrrsrlrrqrrorrr)r*rr as_numer_denomrDrrurqrtrr)rrnrrrrArispolyisratbasepolyratexprris_algrrrWrOrrrwrxr0indicialrrrDrrrrErErFr s          (      "rcst|}|r|\}}}ndSfdd|D}|} | dkr(| dntjfdd|D} dd|D} fdd} | | d| d\} }|d| t|||d }tdt| D]}| | || |\} }|||| t|||d 7}q`|S) Ncsg|]}|dqSr rEry)facrErFr} rz&_convert_meijerint..rr7csg|]}|dqS)r7rEry)rrErFr} rcSrI)rrEryrErErFr} r~c s|jd}|tr|tt}|jdd}t|d}||}|}|dkr/|dnt j }||fdd|jddD}fdd|jddD}fd d|jddD} fd d|jddD} | t ||f| | f|fS) NrF)rrr7c3|]}|VqdSr?rEryrCrErFr r9z5_convert_meijerint.._shift..c3rr?rEryrCrErFr r9c3rr?rEryrCrErFr r9c3rr?rEryrCrErFr r9) rr"r rrrcollectrrr rr&) rrrdr|rrrrrrrirCrF_shift s    z"_convert_meijerint.._shiftr)r' _rewrite1rr rrrrt)rrnrrArporrfac_listrpo_listG_listrr0rrOrwrE)rrrnrFr s   rc s d fdd }|t}t|d\}}|tt|ddtdddg|tt|ddtdddg|tt|dtdd|tt|t|dtdddg|ttdt||dtdddtt g|t tdt||dtdddtt g|t tdt||dtdddtt g|t t|ddtdddg|t t|ddtdddg|tttd|t|dt|ttt|d|dt|d t|ttt|d|dt|d t|ttt |d|dt|d td S) zi Creates the look-up table. For a similar implementation see meijerint._create_lookup_table. rrEcs*t|tg|t||||fdS)z2 Adds a formula in the dictionary N)rrrrr)formularargrrtablerErFadd s  z_create_table..addrWrr7rN)rrE)rrrVrrrrr!rr r"r#rrrr rr)rrArrrrWrErrFr s    $000  $,,2rcCsfg}t|D]*}|||}t|trt|||}|jdus#t|tr&dS||||}q|Sr)rrr]rr2rvrr)rrnrrurrwrrErErFr s      r)rF)NrNNNTrr)tri sympy.corerrrsympy.core.numbersrrrrr r r r sympy.core.singletonr sympy.core.sortingrsympy.core.symbolrrsympy.core.sympifyr(sympy.functions.combinatorial.factorialsrrr&sympy.functions.elementary.exponentialrrr%sympy.functions.elementary.hyperbolicrr(sympy.functions.elementary.miscellaneousr(sympy.functions.elementary.trigonometricrrr'sympy.functions.special.error_functionsrrr r!r"r#'sympy.functions.special.gamma_functionsr$sympy.functions.special.hyperr%r&sympy.integralsr'sympy.matricesr(sympy.polys.ringsr)sympy.polys.fieldsr*sympy.polys.domainsr+r,sympy.polys.polyclassesr-sympy.polys.polyrootsr.sympy.polys.polytoolsr/sympy.polys.matricesr0sympy.printingr1sympy.series.limitsr2sympy.series.orderr3sympy.simplify.hyperexpandr4sympy.simplify.simplifyr5sympy.solvers.solversr6rr8r9r:holonomicerrorsr;r<r=r>rPrVrQrYrrrrrrsympy.integrals.meijerintrrrrrrrr#rrrrrrErErErFs(                     &DW (MP   %9 ) j . %