a Z>m?Z?m@Z@mAZAddlBmCZCddlDmEZEmFZFddlGmHZHmIZImJZJmKZKddlLmMZMmNZNmOZOmPZPddlQmRZRmSZSddlTmUZUmVZVddlWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbddlcmdZdddlemfZfmgZgddlhmiZiddljmkZkdd llmmZmmnZnmoZompZpmqZqdd!lrmsZsmtZtdd"lumvZvdd#lwmxZxmyZymzZzm{Z{m|Z|m}Z}dd$l~mZdd%lmZe&d&Zd'd(Zd)d*Zdd+lmZed,Zd-d.ZGd/d0d0eZd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Zd=d>Zd?d@ZdAdBZdCdDZiadEdFZdGdHZdIdJZd~dLdMZdNdOZddQdRZdSdTZddUdVZdWdXZddYdZZd[d\Zd]d^Zd_d`ZdadbZdcddZdeaeeddfdgZddhdiZdjdkZdldmZdndoZedpdqZdrdsZdtduZdvdwZdxdyZeddzd{Zd|d}ZdeS)a Integrate functions by rewriting them as Meijer G-functions. There are three user-visible functions that can be used by other parts of the sympy library to solve various integration problems: - meijerint_indefinite - meijerint_definite - meijerint_inversion They can be used to compute, respectively, indefinite integrals, definite integrals over intervals of the real line, and inverse laplace-type integrals (from c-I*oo to c+I*oo). See the respective docstrings for details. The main references for this are: [L] Luke, Y. L. (1969), The Special Functions and Their Approximations, Volume 1 [R] Kelly B. Roach. Meijer G Function Representations. In: Proceedings of the 1997 International Symposium on Symbolic and Algebraic Computation, pages 205-211, New York, 1997. ACM. [P] A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990). Integrals and Series: More Special Functions, Vol. 3,. Gordon and Breach Science Publisher )DictTuple) SYMPY_DEBUG)SExpr)Add)cacheit)r) factor_terms)expand expand_mulexpand_power_base expand_trigFunctionMul)ilcmRationalpi)EqNe_canonical_coeff)default_sort_keyordered)DummysymbolsWild) factorial) reimargAbssign unpolarifypolarify polar_liftprincipal_branchunbranched_argumentperiodic_argument)exp exp_polarlog)ceiling)coshsinh_rewrite_hyperbolics_as_expHyperbolicFunctionsqrt) Piecewisepiecewise_fold)cossinsincTrigonometricFunction)besseljbesselybesselibesselk) DiracDelta Heaviside) elliptic_k elliptic_e) erferfcerfiEiexpintSiCiShiChifresnelsfresnelc)gamma)hypermeijerg)SingularityFunction)Integral)AndOr BooleanAtomNotBooleanFunction)cancelfactor) sincos_to_sum)collect gammasimp hyperexpand powdenestpowsimpsimplify)multiset_partitions)debugzcs6t|}t|ddr,tfdd|jDS|jS)N is_PiecewiseFc3s|]}t|gRVqdSN)_has.0ifi/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/integrals/meijerint.py Rz_has..)r3getattrallargshas)resrirjrhrkrdMs rdc s4 dd}tt|d\}tdddgdt tjddf fd d d' fd d }d d}|ddfg d<Gdddt}t  dgggdg tdt dkt  dggdgg tdt dkttd dgggdg tdt dktdt dggdgg tdt dk  dggdgg  tt |dt   dgddgdgddg dt t dtdt  tdk  dggdgg dt t t dd fdd}|dd|dd|tjd|tjdfdd}|dd|dd|tjd|tjdttd ggdggt gdgtjgddg ddt tddt gtjgdgtjtjg ddt tddt ggtjgdg ddtt t ggdgtjg ddtt t ggdgtddg ddtt d fdd fd d!|t td d|t t ddfd"d#}|t |d|t |ttjtddggdgdg fgd|tt |tt t tddgtjgdgdtjg fgd|t |tj t tjtgdgddgg tdfgdt dggtjgddg ddtt dt gdgddgtjg ddtt  dt tjggdgtddtddgtd dd tt dt gtjdgddgtjtjg ddt td$ dt! ggddgg t" dggtjgdg ddtt t# gdgdtjgg ddtt t$ tjggdgtddg d tt t% dggtddgdtddgt d dd%tjt& dggtddgdtddgt d dd%tjt' ggdg dg ddt( gd dgd dgd dg ddt) gddgdg dddg ddt t* ggd dgg ddtjt+ tjtjggdgdg tjt, tjdtjggdgdg tdddd&S)(z8 Add formulae for the function -> meijerg lookup table. cSst|tgdS)Nexclude)rra)nrjrjrkwildXsz"_create_lookup_table..wildZpqabcrucSs|jo |dkSNr) is_Integerxrjrjrk[rmz&_create_lookup_table..)Z propertiesTc s6t|tg||t|||||fg||fdSrc) setdefault_mytyperaappendrM) formulaanapbmbqrfaccondhinttablerjrkadd^sz!_create_lookup_table..addcs$t|tg||||fdSrc)r|r}rar~)rinstrrrrjrkaddibs   z"_create_lookup_table..addicSs0|tdgggdgtf|tgdgdggtfgSNrOr)rMra)arjrjrkconstantfsz&_create_lookup_table..constantrjc@seZdZeddZdS)z2_create_lookup_table..IsNonPositiveIntegercSst|}|jdur|dkSdS)NTr)r"rx)clsrrjrjrkevalns z7_create_lookup_table..IsNonPositiveInteger.evalN)__name__ __module__ __qualname__ classmethodrrjrjrjrkIsNonPositiveIntegerlsrrOr)rcSs(ttdd| |ddd|S)NrrO)rr)rr!nurjrjrkA1sz _create_lookup_table..A1c std|d|dddd|dgg|dg|dgdd|||dS)NrrOr0rZsgn)rrrbtrjrktmpadds , *z$_create_lookup_table..tmpaddrc stt|ttdt|d||dgd||dgdtjggtd|||dS)NrrOr)r1rarHalfr)rrrrpqrjrkrsD2(cs@|}tj|t|tgdg|ddg|dgfgSr)r NegativeOnerrMsubsNrurrjrk make_log1s"z'_create_lookup_table..make_log1cs6|}t|tdg|dggdg|dfgSr)rrMrrrjrk make_log2s"z'_create_lookup_table..make_log2cs||Srcrjr)rrrjrk make_log3sz'_create_lookup_table..make_log3z3/2N)T)-listmaprrarOnerr=rKrQrTr r5rrrr(r$r-rr,r1r4r6r*rMrC ImaginaryUnitrrErFrGrHrDr@rArBrIrJr8r9r:r;r>r?)rrvcrrrrrrj) rrrrrrrurrrrrk_create_lookup_tableVs  ..::4 <6.        48**2   .( " 248, ",,4>>. FD2(r)timethisrMcs`|jvrdS|jrt|fSfdd|jD}g}|D]}|t|7}q:|t|SdS)z4 Create a hashable entity describing the type of f. rjcsg|]}t|qSrj)r}rfrryrjrk 2rmz_mytype..N) free_symbolsZ is_Functiontyperprsorttuple)rirztypesrrrrjryrkr}+s  r}c@seZdZdZdS)_CoeffExpValueErrorzD Exception raised by _get_coeff_exp, for internal use only. N)rrr__doc__rjrjrjrkr:srcCsntt||\}}|s$|tjfS|\}|jrL|j|krBtd||jfS||kr^|tj fStd|dS)a When expr is known to be of the form c*x**b, with c and/or b possibly 1, return c, b. Examples ======== >>> from sympy.abc import x, a, b >>> from sympy.integrals.meijerint import _get_coeff_exp >>> _get_coeff_exp(a*x**b, x) (a, b) >>> _get_coeff_exp(x, x) (1, 1) >>> _get_coeff_exp(2*x, x) (2, 1) >>> _get_coeff_exp(x**3, x) (1, 3) zexpr not of form a*x**bzexpr not of form a*x**b: %sN) r r] as_coeff_mulrZerois_Powbaserr(r)exprrzrmrjrjrk_get_coeff_expAs    rcs"fddt}||||S)a Find the exponents of ``x`` (not including zero) in ``expr``. Examples ======== >>> from sympy.integrals.meijerint import _exponents >>> from sympy.abc import x, y >>> from sympy import sin >>> _exponents(x, x) {1} >>> _exponents(x**2, x) {2} >>> _exponents(x**2 + x, x) {1, 2} >>> _exponents(x**3*sin(x + x**y) + 1/x, x) {-1, 1, 3, y} csV||kr|dgdS|jr:|j|kr:||jgdS|jD]}|||q@dSNrO)updaterrr(rp)rrzrrargument _exponents_rjrkrus  z_exponents.._exponents_set)rrzrrrjrrk _exponentsbs  rcsfdd|tDS)zB Find the types of functions in expr, to estimate the complexity. csh|]}|jvr|jqSrj)rfunc)rferyrjrk rmz_functions..)atomsr)rrzrjryrk _functionssrcs<fdddD\fddt}|||S)ap Find numbers a such that a linear substitution x -> x + a would (hopefully) simplify expr. Examples ======== >>> from sympy.integrals.meijerint import _find_splitting_points as fsp >>> from sympy import sin >>> from sympy.abc import x >>> fsp(x, x) {0} >>> fsp((x-1)**3, x) {1} >>> fsp(sin(x+3)*x, x) {-3, 0} csg|]}t|gdqS)rs)rrfruryrjrkrrmz*_find_splitting_points..Zpqcspt|tsdS|}|rL|dkrL|| |dS|jrVdS|jD]}||q\dSrw) isinstancermatchrZis_Atomrp)rrrrrcompute_innermostrrrzrjrkrs  z1_find_splitting_points..compute_innermostr)rrz innermostrjrrk_find_splitting_pointss   rc Cstj}tj}tj}t|}t|}|D]}||kr>||9}q(||jvrR||9}q(|jr||jjvr|j |\}}||fkrt |j |\}}||fkr|||j9}|t t ||jdd9}q(||9}q(|||fS)aq Split expression ``f`` into fac, po, g, where fac is a constant factor, po = x**s for some s independent of s, and g is "the rest". Examples ======== >>> from sympy.integrals.meijerint import _split_mul >>> from sympy import sin >>> from sympy.abc import s, x >>> _split_mul((3*x)**s*sin(x**2)*x, x) (3**s, x*x**s, sin(x**2)) Fr) rrr r make_argsrrr(rrr r"r#) rirzrpogrprrrrjrjrk _split_muls(       rcCsft|}g}|D]N}|jrV|jjrV|j}|j}|dkrF| }d|}||g|7}q||q|S)a Return a list ``L`` such that ``Mul(*L) == f``. If ``f`` is not a ``Mul`` or ``Pow``, ``L=[f]``. If ``f=g**n`` for an integer ``n``, ``L=[g]*n``. If ``f`` is a ``Mul``, ``L`` comes from applying ``_mul_args`` to all factors of ``f``. rrO)rrrr(rxrr~)rirpgsrrurrjrjrk _mul_argss  rcCsBt|}t|dkrdSt|dkr.t|gSddt|dDS)a Find all the ways to split ``f`` into a product of two terms. Return None on failure. Explanation =========== Although the order is canonical from multiset_partitions, this is not necessarily the best order to process the terms. For example, if the case of len(gs) == 2 is removed and multiset is allowed to sort the terms, some tests fail. Examples ======== >>> from sympy.integrals.meijerint import _mul_as_two_parts >>> from sympy import sin, exp, ordered >>> from sympy.abc import x >>> list(ordered(_mul_as_two_parts(x*sin(x)*exp(x)))) [(x, exp(x)*sin(x)), (x*exp(x), sin(x)), (x*sin(x), exp(x))] rNcSs g|]\}}t|t|fqSrjr)rfrzyrjrjrkrrmz%_mul_as_two_parts..)rlenrr_)rirrjrjrk_mul_as_two_partss    rc Csdd}tt|jt|j}|d|j|d}|dt|d|j}|t||j|||j |||j |||j ||j ||||fS)zO Return C, h such that h is a G function of argument z**n and g = C*h. cSs2g}|D]$}t|D]}||||qq|S)z5 (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) )ranger~)paramsrurrrrgrjrjrkinflates  z_inflate_g..inflaterOr) rrrrrrdeltarMraotherrbotherr)rrurvCrjrjrk _inflate_g srcCs6dd}t||j||j||j||jd|jS)zQ Turn the G function into one of inverse argument (i.e. G(1/x) -> G'(x)) cSsdd|DS)NcSsg|] }d|qSrOrjrrjrjrkr"rmz'_flip_g..tr..rjlrjrjrktr!sz_flip_g..trrO)rMrrrrr)rrrjrjrk_flip_gsrcs|dkrtt|| St|jt|j}t||\}}|j}|dtddtdd}|}fddt D}|t |j |j |j t|j||fS)a\ Let d denote the integrand in the definition of the G function ``g``. Consider the function H which is defined in the same way, but with integrand d/Gamma(a*s) (contour conventions as usual). If ``a`` is rational, the function H can be written as C*G, for a constant C and a G-function G. This function returns C, G. rrrOrcsg|]}|dqSrrjrrrjrkr<rmz"_inflate_fox_h..)_inflate_fox_hrrrrrrrrrrMrrrrr)rrrDrabsrjrrkr&s   & rcKs0t||fi|}||jvr,t|fi|S|S)z Return a dummy. This will return the same dummy if the same token+name is requested more than once, and it is not already in expr. This is for being cache-friendly. )_dummy_rr)nametokenrkwargsdrjrjrk_dummyBs rcKs0||ftvr$t|fi|t||f<t||fS)z` Return a dummy associated to name and token. Same effect as declaring it globally. )_dummiesr)rrrrjrjrkrNs rcs tfdd|ttD S)z Check if f(x), when expressed using G functions on the positive reals, will in fact agree with the G functions almost everywhere c3s|]}|jvVqdSrc)rrfrryrjrkrl\rmz_is_analytic..)anyrr=r )rirzrjryrk _is_analyticYsrTcsr|ddt}dt|ts&|Stdtd\}tktkftt t t kt t dt t ktt t dftt dt t t kt dt t t ktt dftt dt t t kt dt t t kt j ftt t t dt dkt t t dt dktt dftt t t dt dkt t t dt dkt j ftt t dddt ktt t dddt t jftt t dddt ktdddddt jftt tt kt ttd t t jt ktttt j t dftt tt dkt ttt t jt dktttt j t ddftktk|kftddddk@ddkftddtt t t dk@t dkftdtt t t dk@t dkft t t dktt t tt ddk@ddkfg}|jttfd d|j}d }|rd}t|D]\}\}}|j|jkrqt|jD]\}} ||jdjvr&| |jdd} nd} | |jdsDqfd d |jd| |j| ddD} |g| D]} t|jD]\} }| vrq| |kr| g7q|t|tr| jd|krt| tr| jd|jvr| g7q|t|tr| jd|krt| tr| jd|jvr| g7q|qq|tt| dkrpqfdd t|jD|g}tr|dvrtd||j|}d }qʐqqʐqfdd}|dd|}trtd||S)a Do naive simplifications on ``cond``. Explanation =========== Note that this routine is completely ad-hoc, simplification rules being added as need arises rather than following any logical pattern. Examples ======== >>> from sympy.integrals.meijerint import _condsimp as simp >>> from sympy import Or, Eq >>> from sympy.abc import x, y >>> simp(Or(x < y, Eq(x, y))) x <= y cSs|jSrcZ is_Relational_rjrjrkr{srmz_condsimp..Fzp q r)rrrrOcs t|Src) _condsimpr)firstrjrkr{rmTcsg|]}|qSrjrrfrz)rrjrkrrmz_condsimp..Ncsg|]\}}|vr|qSrjrj)rfkZarg_) otherlistrjrkrs ) rrr zused new rule:cs|jdks|jdkr|S|j}|t}|sJ|tt}|st|tr|j dj s|j dt j ur|j ddkS|S|dkS)Nz==rrO) Zrel_oprhslhsrrr&r$rr'rpZis_polarrInfinity)relZLHSr)rrrjrk rel_touchupsz_condsimp..rel_touchupcSs|jSrcrrrjrjrkr{rmz _condsimp: ) replacerrrUrrrRrrQr rrrfalsertruer&r)rr4r1rrrrp enumeraterrrrrprint)rrrrulesZchangeZirulefrotoruZarg1numZ otherargsarg2rZarg3newargsrrj)rrrrrrkr_s (0 08 8:6 " $40B.          rcCst|tr|St|S)z Re-evaluate the conditions. )rboolrZdoit)rrjrjrk _eval_conds rFcCs"t||}|s|tdd}|S)z Bring expr nearer to its principal branch by removing superfluous factors. This function does *not* guarantee to yield the principal branch, to avoid introducing opaque principal_branch() objects, unless full_pb=True. cSs|Srcrj)rzrrjrjrkr{rmz&_my_principal_branch..)r%r)rperiodfull_pbrrrjrjrk_my_principal_branchs r"c st||\}t|j|\}|}t||}|t|dd}fdd}|t||j||j||j||j ||fS)z Rewrite the integral fac*po*g dx, from zero to infinity, as integral fac*G, where G has argument a*x. Note po=x**s. Return fac, G. rOcsfdd|DS)Ncs g|]}|ddqSrrjrrsrjrkrrmz1_rewrite_saxena_1..tr..rjrr#rjrkrsz_rewrite_saxena_1..tr) rr get_periodr"r rMrrrr) rrrrzrrr rrrjr#rk_rewrite_saxena_1s  $r&c Cs|j}t|j|\}}tt|jt|jt|jt|jg\}}}} || krdd} t t | |j| |j | |j| |j |||Sg} |jD]} | t |  dkg7} q|jD]} | ddt | kg7} qt| }|j D]} | t |  dkg7} q|j D]} | ddt | kg7} qt| }t |j | d|d| |k}dd}|d|d|||||| f|d t|jt|j f|d t|jt|j f|d |||fg}g}d|k|| kd|kg}d|kd|kt| |dttt|d t||dg}d|kt| |g}tt|ddD]*}|ttt||d|tg7}q2|d ktt||tkg} t|d |g}|rg}|||fD]}|t|| |g7}q||7}|d ||g}|rg}tt|d |d|k|| ktt||tkg|Rg}||7}|d|||g}|r:g}t|| kd|k|d kttt||tg|Rg}|t|| dkt|d ttt|d g|Rg7}||7}|d|g}|t|| t|d tt|d t|d g7}|s||g7}g}t|j|jD]\} } || | g7}q |t t|d kg7}t|}||g7}|d|gt|d ktt||tkg}|s||g7}t|}||g7}|d|gt|S)aV Return a condition under which the mellin transform of g exists. Any power of x has already been absorbed into the G function, so this is just $\int_0^\infty g\, dx$. See [L, section 5.6.1]. (Note that s=1.) If ``helper`` is True, only check if the MT exists at infinity, i.e. if $\int_1^\infty g\, dx$ exists. cSsdd|DS)NcSsg|] }d|qSrrjrrjrjrkrrmz4_check_antecedents_1..tr..rjrrjrjrkrsz _check_antecedents_1..trrOrcWs t|dSrc_debug)msgrjrjrkr`,sz#_check_antecedents_1..debugz$Checking antecedents for 1 function:z* delta=%s, eta=%s, m=%s, n=%s, p=%s, q=%sz ap = %s, %sz bq = %s, %sz" cond_3=%s, cond_3*=%s, cond_4=%srz case 1:z case 2:z case 3:z extra case:z second extra case:)rrrrrrrrr_check_antecedents_1rMrrrrQrrrrTrr+rr r&rziprrR)rrzhelperretarrrurrrtmprrZcond_3Z cond_3_starZcond_4r`condsZcase1Ztmp1Ztmp2Ztmp3rextrarZcase2Zcase3Z case_extrar$Z case_extra_2rjrjrkr*s 0    $8(   * 6 ,       r*cCst|j|\}}d|}|jD]}|t|d9}q|jD]}|td|d9}q:|jD]}|td|d}qZ|jD]}|t|d}qztt|S)a Evaluate $\int_0^\infty g\, dx$ using G functions, assuming the necessary conditions are fulfilled. Examples ======== >>> from sympy.abc import a, b, c, d, x, y >>> from sympy import meijerg >>> from sympy.integrals.meijerint import _int0oo_1 >>> _int0oo_1(meijerg([a], [b], [c], [d], x*y), x) gamma(-a)*gamma(c + 1)/(y*gamma(-d)*gamma(b + 1)) rO) rrrrKrrrrZr")rrzr-rrrrrrjrjrk _int0oo_1ys    r1csfdd}t|\}}t|j\}} t|j\}} | dkdkrV| } t|}| dkdkrp| } t|}| jr|| jsdS| j| j} } | j| j} }t| || | }|| |}|| | }t||\}}t||\}}||}||}|||9}t|j\}}t|j\}}|d|d|t||}fdd}t ||j ||j ||j ||j |}t |j |j |j |j |}t|dd ||fS) a Rewrite the integral ``fac*po*g1*g2`` from 0 to oo in terms of G functions with argument ``c*x``. Explanation =========== Return C, f1, f2 such that integral C f1 f2 from 0 to infinity equals integral fac ``po``, ``g1``, ``g2`` from 0 to infinity. Examples ======== >>> from sympy.integrals.meijerint import _rewrite_saxena >>> from sympy.abc import s, t, m >>> from sympy import meijerg >>> g1 = meijerg([], [], [0], [], s*t) >>> g2 = meijerg([], [], [m/2], [-m/2], t**2/4) >>> r = _rewrite_saxena(1, t**0, g1, g2, t) >>> r[0] s/(4*sqrt(pi)) >>> r[1] meijerg(((), ()), ((-1/2, 0), ()), s**2*t/4) >>> r[2] meijerg(((), ()), ((m/2,), (-m/2,)), t/4) c s@t|j\}}|}t|j|j|j|jt|||Src) rrr%rMrrrrr")rrrZper)r!rzrjrkpbs z_rewrite_saxena..pbrTNrOcsfdd|DS)Ncsg|] }|qSrjrjrr(rjrkrrmz/_rewrite_saxena..tr..rjrr3rjrkrsz_rewrite_saxena..trZpolar)rrr is_Rationalrrrrr rMrrrrr\)rrg1g2rzr!r2rr$b1b2m1Zn1m2Zn2taur1Zr2C1C2a1ra2rrj)r(r!rzrk_rewrite_saxenas<       ,rBc+s*tj|\ }tj|\}ttjtjtjtjg\}} ttjtjtjtjg\}}|| d}||d} j ddjdd } d } t ||t t t ||t t   t dt d || |ft d||| ft d| |  ffdd} | } t fd d jD}t fd d jD}t fd d jD}t fd d jD}t  fdd jD}t  fdd jD}t | dtd d dk}t | dtd d dk}t t |t k}tt t |t }t t | t k}tt t | t }t||  t tj}t| }t| }|d|krt t| d|| dktt|dt  dktdk}ndd}t t| d|d| dktt t|d||t t  dkt|d}t t| d| d|dktt t|d||t tdkt|d}t||}zt dt t d t } t| dkdkr| dk}!n: fdd}"t|"dd|"ddt tt dtt df|"tt d|"tt dt tt dtt df|"dtt |"dtt t tt dtt df|"tt tt df}#| dkt t| dt|#dt| dkt t| dt|#dt| dkg}$t|$}!Wnty0d}!Yn0| df|df|df|df|df|df|df|df|df|df|d f|d!f|d"f|d#f|!d$ffD]\}%}&t d%|&|%qgfd&d'}'t ||||dk|jdu| jdu| ||||g7|'dt t t|d| jdu jdutdk| ||| g7|'dt tt| d|jdujdutdk| ||| g7|'dt tt t|dt| d jdujdutdktdkt | || g7|'dt tt t|dt| d jdujdutdkt | || g7|'dt k|jdu|jdu| dk| ||||| g7|'dt k|jdu|jdu| dk| ||||| g7|'dt k|jdu| jdu|dk| ||||| g7|'dt k|jdu| jdu|dk| ||||| g7|'dt kt t|d| dk jdutdk| |||| g7|'dt kt t|d| dk jdutdk| |||| g7|'d t t k|dkt| djdutdk| |||| g7|'d!t t k|dkt| djdutdk| |||| g7|'d"t k k|dk| dk| |||||| g7|'d#t k k|dk| dk| |||||| g7|'d$t k k|dk| dk| |||||||| g7|'d(t k k|dk| dk| |||||||| g7|'d)t t|d|jdu|jdu| jdu| ||g7|'d*t t|d|jdu|jdu| jdu| ||g7|'d+t t|d|jdu| jdu| jdu| ||g7|'d,t t|d|jdu| jdu| jdu| ||g7|'d-t t||d|jdu| jdu| ||||g7|'d.t t||d|jdu| jdu| ||||g7|'d/t|dd0}(t|dd0})t |)t|d |k|jdu|| ||g7|'d1t |)t|d |k|jdu|| ||g7|'d2t |(t|d|k| jdu|| ||g7|'d3t |(t|d|k| jdu|| ||g7|'d4t}*t|*dk r|*St ||kt|dt| d|jdu|jdu| jdut t ||dt k| ||||! g7|'d5t ||kt|dt| d|jdu|jdu| jdut t ||dt k| ||||! g7|'d6t tdt|dt| d|jdu|jdu| dk| t t t k| ||||! g7|'d7t tdt|dt| d|jdu|jdu| dk| t t t k| ||||! g7|'d8t dkt|dt| d|jdu|jdu| dk| t t t kt t ||dt k| ||||! g7|'d9t dkt|dt| d|jdu|jdu| dk| t t t kt t ||dt k| ||||! g7|'d:t t|dt| d||dk|jdu| jdu|jdut t || dt k| ||||! g7|'d;t t|dt| d|| k|jdu| jdu|jdut t || dt k| ||||! g7|'d<t t|dt| dt d|jdu| jdu|dk|t t t kt t |dt k| ||||! g7|'d=t t|dt| dt d|jdu| jdu|dk|t t t kt t |dt k| ||||! g7|'d>t t|dt| d dk|jdu| jdu|dk|t t t kt t || dt k| ||||! g7|'d?t t|dt| d dk|jdu| jdu|dk|t t t kt t || dt k| ||||! g7|'d@tS)Az> Return a condition under which the integral theorem applies. rrOzChecking antecedents:z1 sigma=%s, s=%s, t=%s, u=%s, v=%s, b*=%s, rho=%sz1 omega=%s, m=%s, n=%s, p=%s, q=%s, c*=%s, mu=%s,z" phi=%s, eta=%s, psi=%s, theta=%scsHfD]:}|jD].}|jD]"}||}|jr|jrdSqqqdS)NFT)rr is_integer is_positive)rrgjdiff)r6r7rjrk_c1s    z_check_antecedents.._c1cs,g|]$}jD]}td||dkqqSrOr)rrrfrgrEr7rjrkrrmz&_check_antecedents..cs,g|]$}jD]}td||dkqqS)rOr)rrrIrJrjrkr rmcs6g|].}td|dttddkqSrOrrrremurrrjrkr rmcs2g|]*}td|ttddkqSrKrMrerNrjrkr rmcs6g|].}td|dttddkqSrKrMrerhourrjrkr rmcs2g|]*}td|ttddkqSrKrMrerPrjrkr rmrcSs|dkottd|tkS)aReturns True if abs(arg(1-z)) < pi, avoiding arg(0). Explanation =========== If ``z`` is 1 then arg is NaN. This raises a TypeError on `NaN < pi`. Previously this gave `False` so this behavior has been hardcoded here but someone should check if this NaN is more serious! This NaN is triggered by test_meijerint() in test_meijerint.py: `meijerint_definite(exp(x), x, 0, I)` rO)r rrrarjrjrk_cond*s z!_check_antecedents.._condFcsP|tdt|tdtSr)r r5)c1c2)omegarpsirsigmathetarRrrjrk lambda_s0Ys&&z%_check_antecedents..lambda_s0rTrrrrr  r r r r z c%s:cstd|ddS)Nz case %s:rr')count)r/rjrkprrsz_check_antecedents..prr)r,ZE1ZE2ZE3ZE4 !"#)rrrrrrrrrrr r&r(rQrrr(rr"rRrr4rr2r! TypeErrorrDZ is_negativer*)+r6r7rzrr$rrruZbstarZcstarphir-rGrUrVc3Zc4Zc5Zc6Zc7Zc8Zc9Zc10Zc11Zc12Zc13Zz0ZzosZzsoZc14rTZc14_altZlambda_cZc15r[Zlambda_sr.rrgraZ mt1_existsZ mt2_existsrrj) r/r6r7rOrWrrXrrQrYrZrRrrk_check_antecedentss 00$$* *   "" "" ""  $  ...$$$        ((((2222    ,,,,6 6 0 0 . 0 6 6 0 0 0 0 rxc Cst|j|\}}t|j|\}}dd}||jt|j}t|j||j}||jt|j} t|j||j} t||| | |||S)a Express integral from zero to infinity g1*g2 using a G function, assuming the necessary conditions are fulfilled. Examples ======== >>> from sympy.integrals.meijerint import _int0oo >>> from sympy.abc import s, t, m >>> from sympy import meijerg, S >>> g1 = meijerg([], [], [-S(1)/2, 0], [], s**2*t/4) >>> g2 = meijerg([], [], [m/2], [-m/2], t/4) >>> _int0oo(g1, g2, t) 4*meijerg(((1/2, 0), ()), ((m/2,), (-m/2,)), s**(-2))/s**2 cSsdd|DS)NcSsg|] }| qSrjrjrrjrjrkr$rmz(_int0oo..neg..rjrrjrjrkneg#sz_int0oo..neg)rrrrrrrrM) r6r7rzr-rrWryr@rAr8r9rjrjrk_int0oosrzcsnt||\}t|j|\}fdd}t||ddt||j||j||j||j|jfS)z Absorb ``po`` == x**s into g. csfdd|DS)Ncsg|]}|qSrjrj)rfrr#rjrkr2rmz2_rewrite_inversion..tr..rjrr#rjrkr1sz_rewrite_inversion..trTr4)rrr\rMrrrr)rrrrzrrrrjr#rk_rewrite_inversion,s (r{csRtdjt\}}|dkr:tdttSfddfddttjtjtj tj g\}}}}|||}|||} || d} ||d krtj } nd krd } ntj } d dt j t j j} td |||||| | ftd | | fj|dksZ|d krN||ksZtd d SjD]:} jD],}| |jrj| |krjtdd Sqjq`||krtdtfddjDSfdd}fdd}fdd}fdd}g}|td |kd |k| t| tdk| dk|ttjt| d g7}|t|d |k|d |k| dk| tdk|dk||d t| tdk|ttjt|||ttj t||g7}|t||k|dk| dk| t| tdk|g7}|ttt||dkd |k|dkt|d ||k||||dk| dk| tdk|d t| tdk|ttjt| |ttj t| g7}|td |k| dk| dk| | ttdk|| t| tdk|ttjt| |ttj t| g7}||dkg7}t|S)z7 Check antecedents for the laplace inversion integral. z#Checking antecedents for inversion:rz Flipping G.c s t|\}}||9}|||9}||9}g}|ttjt|td}|ttj t|td} |rv|} n| } |ttt|dt|dkt|dkg7}|tt |dtt |dt|dkt| dkg7}|tt |dtt |dt|dkt| dkt|dkg7}t|S)Nrrr) rr(rrrrrQrRrrr) rrrrapluscoeffexponentr/ZwpZwmwryrjrkstatement_halfAs   ,4, z4_check_antecedents_inversion..statement_halfcs"t||||d||||dS)zW Provide a convergence statement for z**a * exp(b*z**c), c/f sphinx docs. TF)rQ)rrrra)rrjrk statementSsz/_check_antecedents_inversion..statementrrOz9 m=%s, n=%s, p=%s, q=%s, tau=%s, nu=%s, rho=%s, sigma=%sz epsilon=%s, theta=%s, delta=%sz- Computation not valid for these parameters.Fz Not a valid G function.z$ Using asymptotic Slater expansion.csg|]}|dddqSrHrjrrrarjrkrrmz0_check_antecedents_inversion..cstfddjDS)Ncsg|]}|dddqSrHrjrrrjrkrrmz;_check_antecedents_inversion..E..)rQrrS)rrrSrkEsz'_check_antecedents_inversion..Ecs d|SrrjrS)rYrrZrjrkHsz'_check_antecedents_inversion..Hcs d|dS)NrOTrjrSrYrrZrjrkHpsz(_check_antecedents_inversion..Hpcs d|dS)NrOFrjrSrrjrkHmsz(_check_antecedents_inversion..Hm)r(rr_check_antecedents_inversionrrrrrrrrNaNrrrCrQrr(rrR)rrzrrrrurrr<rrQepsilonrrrrrrrr/rj)rrYrrrZrzrarkr7s  0   $$   (.$$&(rc CsHt|j|\}}tt|j|j|j|j|||| \}}|||S)zO Compute the laplace inversion integral, assuming the formula applies. )rrrrMrrrr)rrzrrrrrjrjrk_int_inversions,rNc s<ddlm}mm}mts(iattt|trt |j | |\}}t |dkrXdS|d}|j r~|j|ksx|jjsdSn ||krdSddt|j|j|j|j||fgdfS|}||t}t|t}|tvrht|} | D]\} } } } |j| dd}|ri}|D]"\}}tt|dddd||<q|}t| tsL| |} | d krXqt| ttfsvt| |} t| d krqt| ts| |} g}| D]\}}t t||t|dd|}z||t|}Wnt!yYqYn0t"||f#t$j%t$j&t$j'r qt|j|j|j|jt|j dd}|(||fq|r|| fSq|srdSt)d fd d }|}t*d d|}dd}z,|||||d dd\}}}|||||}Wn|yd}Yn0|durlt+dd}||j,vrlt-||rlz@||||||||dd d\}}}||||||d}Wn|yjd}Yn0|dus|#t$j%t$j.t$j&rt)ddSt/0|}g}|D]~}| |\}}t |dkrt1d|d}t |j |\}}||dt|j|j|j|jtt|dddd||fg7}qt)d||dfS)aH Try to rewrite f as a sum of single G functions of the form C*x**s*G(a*x**b), where b is a rational number and C is independent of x. We guarantee that result.argument.as_coeff_mul(x) returns (a, (x**b,)) or (a, ()). Returns a list of tuples (C, s, G) and a condition cond. Returns None on failure. rO)mellin_transforminverse_mellin_transformIntegralTransformErrorMellinTransformStripErrorNrT)old)Zlift)Zexponents_onlyFz)Trying recursive Mellin transform method.c sNz||||dddWSyHttt||||dddYS0dS)z Calling simplify() all the time is slow and not helpful, since most of the time it only factors things in a way that has to be un-done anyway. But sometimes it can remove apparent poles. T)Z as_meijergneedevalN)r^rVr )Fr$rzstriprrrjrkmy_imts  z_rewrite_single..my_imtr$zrewrite-singlecSsdt||dd}|durP|\}}tt|dd}t||ft||tjtjfdfSt||tjtjfS)NT) only_doubleZ nonrepsmall)Zrewrite)_meijerint_definite_4_my_unpolarifyr[r2rPrrr)rirzrrrrrjrjrk my_integrator sz&_rewrite_single..my_integrator) integratorr^rr)rrr^z"Recursive Mellin transform failed.zUnexpected form...z"Recursive Mellin transform worked:)2 transformsrrrr _lookup_tablerrrMrWrrrrrr(r5rrrrrrar}ritemsr"r#rrSrrr ValueErrorrrqrrComplexInfinityNegativeInfinityr~r(rrrrrrrNotImplementedError) rirz recursiverrr}rf_rrrZtermsrrrZsubs_rrrrrrr=rr$rrrrrrprrrjrrk_rewrite_singles   (                        rcCs8t||\}}}t|||}|r4|||d|dfSdS)z Try to rewrite ``f`` using a (sum of) single G functions with argument a*x**b. Return fac, po, g such that f = fac*po*g, fac is independent of ``x``. and po = x**s. Here g is a result from _rewrite_single. Return None on failure. rrON)rr)rirzrrrrrjrjrk _rewrite1Ns rc st|\}}}tfddt|Dr.dSt|}|s>dStt|fddfddfddg}dD]j}|D]`\}}t||} t||} | rv| rvt| d | d } | d krv||| d | d | fSqvqndS) a  Try to rewrite ``f`` as a product of two G functions of arguments a*x**b. Return fac, po, g1, g2 such that f = fac*po*g1*g2, where fac is independent of x and po is x**s. Here g1 and g2 are results of _rewrite_single. Returns None on failure. c3s|]}t|dduVqdS)FN)rrryrjrkrlermz_rewrite2..Ncs&ttt|dtt|dSNrrO)maxrrrryrjrkr{krmz_rewrite2..cs&ttt|dtt|dSr)rrrrryrjrkr{lrmcs&ttt|dtt|dSr)rrrrryrjrkr{msFTrOFr)rrrrrrrrQ) rirzrrrrrZfac1Zfac2r6r7rrjryrk _rewrite2\s&      rcCsg}tt||tjhBtdD]P}t|||||}|s>q||||}t|tt rf| |q|Sq| t rt dtt||}|rt|tstt||tS|||rtt|SdS)a# Compute an indefinite integral of ``f`` by rewriting it as a G function. Examples ======== >>> from sympy.integrals.meijerint import meijerint_indefinite >>> from sympy import sin >>> from sympy.abc import x >>> meijerint_indefinite(sin(x), x) -cos(x) )key*Try rewriting hyperbolics in terms of exp.N)sortedrrrr_meijerint_indefinite_1rrdrLrMr~rqr/r(meijerint_indefiniter.rrrYr rr(extendnextr)rirzresultsrrrrvrjrjrkrzs(       rcs(td|dt|}|dur$dS|\}}}}td|tj}|D]X\}} } t| j\} } t|\} }|| 7}||| | d|| }|d| dtddtj}fdd }td d || j Drt || j || j dg|| j d g|| j | }n4t || j dg|| j || j || j d g|}| jrj|d tjtjsjd }nd}t||| | |d }|t||dd7}qDfdd}t|dd}|jrg}|jD]$\}}t||}|||fg7}qt|ddi}n t||}t|t|ft|dfS)z0 Helper that does not attempt any substitution. z,Trying to compute the indefinite integral ofZwrtNz could rewrite:rOrzmeijerint-indefinitecsfdd|DS)Ncsg|]}|dqSrrjrrQrjrkrrmz7_meijerint_indefinite_1..tr..rjrrrjrkrsz#_meijerint_indefinite_1..trcss |]}|jo|dkdkVqdS)rTN)rC)rfrrjrjrkrlrmz*_meijerint_indefinite_1..r)placeTr4cs$tt|dd}t|dS)aThis multiplies out superfluous powers of x we created, and chops off constants: >> _clean(x*(exp(x)/x - 1/x) + 3) exp(x) cancel is used before mul_expand since it is possible for an expression to have an additive constant that doesn't become isolated with simple expansion. Such a situation was identified in issue 6369: Examples ======== >>> from sympy import sqrt, cancel >>> from sympy.abc import x >>> a = sqrt(2*x + 1) >>> bad = (3*x*a**5 + 2*x - a**5 + 1)/a**2 >>> bad.expand().as_independent(x)[0] 0 >>> cancel(bad).expand().as_independent(x)[0] 1 F)deeprO)r rVrZ _from_argsZ as_coeff_add)rrryrjrk_cleansz'_meijerint_indefinite_1.._clean)evaluaterF)r(rrrrrrrrrrMrrrZis_extended_nonnegativerrqrrr[r\r3rbrprr2rP)rirzrrrglrrrrr$rrrrrZfac_rrrrrrrrj)rQrzrkrsJ     .."    rcCstd|d|||f|tr,tddS|trBtddS||||f\}}}}td}|||}|}||krtjdfSg} |tjur|tj urt ||| || | S|tjurtdt ||} td | t | t dd tjgD]} td | | jstd qt|||| |} | dur|tj urt ||D]t}||dkdkr>td|t||||t||||}|r>t|dtr| |n|Sq>||||}||}d}|tj ur ttjt|}t|}||||}|t|||9}tj }td||td|t||}|rft|dtrb| |n|S|trtdt t||||}|rt|tstt|d|d tf|dd}|S| !|| rt"t#| SdS)a Integrate ``f`` over the interval [``a``, ``b``], by rewriting it as a product of two G functions, or as a single G function. Return res, cond, where cond are convergence conditions. Examples ======== >>> from sympy.integrals.meijerint import meijerint_definite >>> from sympy import exp, oo >>> from sympy.abc import x >>> meijerint_definite(exp(-x**2), x, -oo, oo) (sqrt(pi), True) This function is implemented as a succession of functions meijerint_definite, _meijerint_definite_2, _meijerint_definite_3, _meijerint_definite_4. Each function in the list calls the next one (presumably) several times. This means that calling meijerint_definite can be very costly. Integratingzwrt %s from %s to %s.z+Integrand has DiracDelta terms - giving up.Nz5Integrand has Singularity Function terms - giving up.rzTz Integrating -oo to +oo.z Sensible splitting points:)rreversez Trying to split atz Non-real splitting point.z' But could not compute first integral.z( But could not compute second integral.Fz) But combined condition is always false.rrOzTrying x -> x + %szChanged limits tozChanged function tor)$r(rqr<rNrrrrrrmeijerint_definiterrrZis_extended_real_meijerint_definite_2rrQrdrMr~r=r(rrr r/r.rrrYr rrrr)rirzrrrZx_Za_Zb_rrrrZres1Zres2Zcond1Zcond2rrrsplitrvrrjrjrkrs                          * rcCs|dfg}|dd}|h}t|}||vrD||dfg7}||t|}||vrl||dfg7}|||ttrtt|}||vr||dfg7}|||ttrt |}||vr||dfg7}|||S)z6 Try to guess sensible rewritings for integrand f(x). zoriginal integrandrrr r zexpand_trig, expand_mulztrig power reduction) r rr rqr7r/r r4r5rX)rirzrrorigZsawZexpandedZreducedrjrjrk_guess_expansions,         rcCsjtdd|dd}|||}|}|dkr2tjdfSt||D](\}}td|t||}|r<|Sq.css|]}|duVqdSrcrj)rfrrjrjrkrlrmz(_meijerint_definite_3..N)rZis_Addr(rprorrrQ)rirzrrressr/rrrjryrkrs   rcCs tt|Src)rr"rhrjrjrkrsrc Cs4td||st||dd}|dur|\}}}}td|||tj}|D]`\} } }| dkr\qHt|| ||| ||\} }|| t||7}t|t||}|dkrHqqHt|}|dkrtdntd|tt ||fSt ||}|dur0d D]6} |\}}} } }td ||| | tj}| D]\}}}| D]\}}}t ||||||||||| }|dur~td dS|\} }}td | ||t|t |||}|dkrq|| t |||7}q2q$qސq$t|}|dkrtd | qtd||r||fStt ||fSqdS)a Try to integrate f dx from zero to infinity. Explanation =========== This function tries to apply the integration theorems found in literature, i.e. it tries to rewrite f as either one or a product of two G-functions. The parameter ``only_double`` is used internally in the recursive algorithm to disable trying to rewrite f as a single G-function. rF)rN#Could rewrite as single G function:rBut cond is always False.z&Result before branch substitutions is:rz!Could rewrite as two G functions:zNon-rational exponents.zSaxena subst for yielded:z&But cond is always False (full_pb=%s).)r(rrrr&r1rQr*rr[rrBrxrz)rirzrrrrrrrrrr$r!r6r7r>s1f1r?s2f2rZf1_Zf2_rjrjrkrsb               rcCsZ|}|}tddd}|||}td|t||s@tddStj}|jrXt|j}nt |t rj|g}nd}|rg}g}|r| } t | t rt | } | jr|| j7}q|zt | jd|\} } Wntyd} Yn0| dkr|| n || q|| jrt | } | jr"|| j7}q||| jjvr|zt | j |\} } Wnty\d} Yn0| dkr||| t| j|| q||| q|t|}t|}||jvrtd ||tt|d} | d krtd dS|t||}td || t|||| fSt||}|durV|\}}}} td |||tj}|D]^\}}}t|||||||\}}||t|||7}t| t||} | d krHqqHt| } | d krtdntd|tt |}|!t"s|t"|9}||||}t | t#s| |||} ddl$m%}t|||| f||||||ddfSdS)a Compute the inverse laplace transform $\int_{c+i\infty}^{c-i\infty} f(x) e^{tx}\, dx$, for real c larger than the real part of all singularities of ``f``. Note that ``t`` is always assumed real and positive. Return None if the integral does not exist or could not be evaluated. Examples ======== >>> from sympy.abc import x, t >>> from sympy.integrals.meijerint import meijerint_inversion >>> meijerint_inversion(1/x, x, t) Heaviside(t) rTr4zLaplace-invertingzBut expression is not analytic.NrrOz.Expression consists of constant and exp shift:Fz3but shift is nonreal, cannot be a Laplace transformz1Result is a delta function, possibly conditional:rrz"Result before branch substitution:)InverseLaplaceTransform)&rrr(rrrZis_Mulrrprr(popr rrr~rrrr*rrrrr<r2rr{rrQrrr[rqr=rrr)rirzrrZt_shiftrprZ exponentialsrrrrrrrrrrrrr$rrjrjrkmeijerint_inversion s                                  r)T)F)F)F)T)T)F)rtypingrZtDictrZtTupleZsympyrZ sympy.corerrZsympy.core.addrZsympy.core.cacherZsympy.core.containersZsympy.core.exprtoolsr Zsympy.core.functionr r r r rZsympy.core.mulrZsympy.core.numbersrrrZsympy.core.relationalrrrZsympy.core.sortingrrZsympy.core.symbolrrrZ(sympy.functions.combinatorial.factorialsrZ$sympy.functions.elementary.complexesrrrr r!r"r#r$r%r&r'Z&sympy.functions.elementary.exponentialr(r)r*Z#sympy.functions.elementary.integersr+Z%sympy.functions.elementary.hyperbolicr,r-r.r/Z(sympy.functions.elementary.miscellaneousr1Z$sympy.functions.elementary.piecewiser2r3Z(sympy.functions.elementary.trigonometricr4r5r6r7Zsympy.functions.special.besselr8r9r:r;Z'sympy.functions.special.delta_functionsr<r=Z*sympy.functions.special.elliptic_integralsr>r?Z'sympy.functions.special.error_functionsr@rArBrCrDrErFrGrHrIrJZ'sympy.functions.special.gamma_functionsrKZsympy.functions.special.hyperrLrMZ-sympy.functions.special.singularity_functionsrNZ integralsrPZsympy.logic.boolalgrQrRrSrTrUZ sympy.polysrVrWZsympy.simplify.furXZsympy.simplifyrYrZr[r\r]r^Zsympy.utilities.iterablesr_Zsympy.utilities.miscr`r(rardrZsympy.utilities.timeutilsrZtimeitr}rrrrrrrrrrrrrrrrrrr"r&r*r1rBrxrzr{rrrrrrrrrrrrrrrrjrjrjrks       4  4        R !!$'    {  s H3 {  #Y   F