wgRdZddlZddlZddlmZmZmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZmZmZmZmZmZddlmZmZdd lmZmZmZmZm Z m!Z!m"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/m0Z0dd l1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDddlEmFZFmGZGmHZHmIZIddlJmKZKmLZLddlMmNZNmOZOmPZPddlQmRZRmSZSmTZTmUZUddlVmWZWddlXmYZYmZZZddl[m\Z\m]Z]m^Z^ddl_m`Z`maZambZbmcZcmdZdddlemfZfddlgmhZhddlimjZjddlkmlZlddlmmnZnddlompZpdd lqmrZrdd!lsmtZtmuZumvZvdd"lwmxZxdayd#Zzd$Z{d%Z|ezd&Z}ezd'Z~ezd(Ze d)Zezd*Zezd+Zezd,Zezd-Zezd.Zezd/Zezd0Zezd1Zezd2Zezd3Zezd4Zezd5Zezd6Zezd7Zd8Zd9Zezd:ZGd;dZezd?Ze d@ZezdAZezdBZezdCZezdDZezdEZezdFZezdGZezdHZezdIZezdJZezdKZGdLdMe]ZdQdNZdOZy)RzLaplace TransformsN)SpiI)Add)cacheit)Expr) AppliedUndef Derivativeexpandexpand_complex expand_mul expand_trigLambda WildFunctiondiffSubs)Mulprod) _canonicalGeGtLt UnequalityEqNe Relational)ordered)DummysymbolsWild)reimargAbs polar_liftperiodic_argument)explog)coshcothsinhasinh)MaxMinsqrt) Piecewisepiecewise_exclusive)cossinatansinc)besselibesseljbesselkbessely) DiracDelta Heaviside)erferfcEi)digammagamma lowergamma uppergamma)SingularityFunction) integrateIntegral) _simplifyIntegralTransformIntegralTransformError)to_cnf conjuncts disjunctsOrAnd) MatrixBase) _lin_eq2dict)PolynomialError)roots)Poly)together)RootSum)sympy_deprecation_warningSymPyDeprecationWarningignore_warnings)debugfcfd}|S)Ncfddlm}|s|i|Stdk(rtdtj tddtzj |tj tdz aj dk(sj d k(rDd t_td dtzztj |i|}d t_n|i|}tdzatddtzd |tj tdk(rtdtj |S)Nr SYMPY_DEBUGzO ------------------------------------------------------------------------------file-LT-  _laplace_transform_integration&_inverse_laplace_transform_integrationFz**** %sIntegrating ...Tz---> zO------------------------------------------------------------------------------ )sympyr\ _LT_levelprintsysstderr__name__)argskwargsr\resultfuncs \/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/integrals/laplace.pywrapzDEBUG_WRAP..wrap1s%(( ( > -cjj 1 tI~t}}dC:: Q  !AA !II %E  *d9n=CJJ O4*6*F $E 4*6*FQ  $y.&9 K > -cjj 1 )rmros` rn DEBUG_WRAPrr0s4 Krpcdddlm}|r(tddtz|tj yy)Nrr[r_r`r])rdr\rfrergrh)textr\s rn_debugruNs&! T)^T2Drpcfdfdfdfd}d}ddlm}||}||t}||tfd}||t|}t |S) a Naively simplify some conditions occurring in ``expr``, given that `\operatorname{Re}(s) > a`. Examples ======== >>> from sympy.integrals.laplace import _simplifyconds >>> from sympy.abc import x >>> from sympy import sympify as S >>> _simplifyconds(abs(x**2) < 1, x, 1) False >>> _simplifyconds(abs(x**2) < 1, x, 2) False >>> _simplifyconds(abs(x**2) < 1, x, 0) Abs(x**2) < 1 >>> _simplifyconds(abs(1/x**2) < 1, x, 1) True >>> _simplifyconds(S(1) < abs(x), x, 1) True >>> _simplifyconds(S(1) < abs(1/x), x, 1) False >>> from sympy import Ne >>> _simplifyconds(Ne(1, x**3), x, 1) True >>> _simplifyconds(Ne(1, x**3), x, 2) True >>> _simplifyconds(Ne(1, x**3), x, 0) Ne(1, x**3) c`|k(ry|jr|jk(r |jSy)Nra)is_Powbaser')exss rnpowerz_simplifyconds..powerws* 7 99A66Mrpc|jr|jryt|tr|jd}t|tr|jd}|jrd|z d|z S|}|y |dkDr,t|t|zktj k(ry|dkr-t|t|zk\tj k(ryyy#t $rYywxYw)z_ Return True only if |ex1| > |ex2|, False only if |ex1| < |ex2|. Else return None. NrraFT)has isinstancer$rjrtrue TypeError)ex1ex2nabiggerr|r{s rnrz_simplifyconds..bigger~s 771:#''!* c3 ((1+C c3 ((1+C 771:!C%3' ' #J 9 1u#c(c!fai/AFF:1u#c(c!fai/AFF:;u  s0C30C33 C?>C?c|jst|tr|jst|ts||kS||}|| S||kS)z simplify x < y ) is_positiverr$)xyrrs rnrepliez_simplifyconds..repliesL*Q"4 As);EN 1aL =5LArpc8||}|dvryt||S)NTFT)r)rrbrs rnrepluez_simplifyconds..replues& 1aL !Qrpc>|dvr t|S|j|S)Nr)boolreplace)rzrjs rnreplz_simplifyconds..repls$  8Orzz4  rpr) collect_absc||SNrq)rrrs rnz _simplifyconds..s va|rp)sympy.simplify.radsimprrrrr) exprr{rrrrrr|rs `` @@@rn_simplifycondsrVs`B, ! 3 t D b& !D b3 4D j& )D T7Nrpc@t||jtS)zs Expand an expression involving DiractDelta to get it as a linear combination of DiracDelta functions. )rOatomsr:rs rnexpand_dirac_deltars djj4 55rpctd|jtryt|t  zzt j t jf}|jts;t|j|t jt jfS|jsy|jd\}}|jtryfd}t|Dcgc] }|| }}|D cgc]0} | dt j k7s| dt jur| 2} } | s&|D cgc]} | dt j k7s| } } t#t%| }d|j'fd|sy|d\} } fd } |rt)|| }t)| | } t|j|| | t+| | fScc}wcc} wcc} w) z The backend function for doing Laplace transforms by integration. This backend assumes that the frontend has already split sums such that `f` is to an addition anymore. r{Nrcddlm}tj}tj}t t |}tdtg\}}}}}} } |tt|z|zz|k|tt|z|zz|ktt|z|z|z||ktt|z|z|z||kttt|z|z|z||kttt|z|z|z||kf} |D]} tj} g}t| D]}|jr$|j j"vr |j$}|jr"t'|t(t*fr |j,}| D]}|j/|snr9|j0r*||z t2dz k(rt5|z dk}|j/|t7|tt| zz|zt|z| zzz dksN|j/t7|tt|z| z||zz t|z| zzdksW|j/|t7ttt|z| z||zt|z| zzz dkr*t9fd|||| | fDrt5|kD}|j;t4dj=t5}|jr0|j>dvs"|jAs|jAs||gz }O||}|jr|j>dvr||gz }z|jBk(ry tE|jB| } | tjurtG| |}tI|tK|}||jr |jLfS|fS) z7 Turn ``conds`` into a strip and auxiliary conditions. r_solve_inequalityzp q w1 w2 w3 w4 w5clsexcludec3<K|]}|jywr)r).0wildms rn zH_laplace_transform_integration..process_conds..s-TQtW00-scD|jjdSNr)r as_real_imag)rs rnrzG_laplace_transform_integration..process_conds..s!((*"9"9";A">rp)z==z!=N)'sympy.solvers.inequalitiesrrNegativeInfinityrrJrIrr r$r#r&r%InfinityrK is_Relationalrhs free_symbolsreversedrrr reversedsignmatchrrr!r2allrsubsrel_opr~ltsr.r-rMrL canonical)condsrrauxpqw1w2w3w4w5patternsca_aux_dpatd_solnrr{ts @rn process_condsz5_laplace_transform_integration..process_condss@  ff&-(#* dQC$9 1b"b"b c#q2vqj/" "R ' c#q2vqj/" "b ( !1r6A+a-4 5 : !1r6A+a-4 5 ; !:a"f#5"9!";R@ AB F !:a"f#5"9!";R@ AR G I- *ABDq\& +??qAEE,>,>'> A??z!b"X'>A#C A1))aeAaDjBqD.@A"I*AGGABs3qt9~$5b$8 9#ae*b. HH1LMA$5aeBh$B CB FFGArE B')*+,AC 1*Q-2CB2F JKBN!!R%j"n--/012A-BB>,--1! AYY>@@DRUAOOqxx.cnts = ~~rpc&|d |dfSNrrarq)rrs rnrz0_laplace_transform_integration..sqteS1Y/rpkeyc(|jSr)r)rr{s_s rnsbsz+_laplace_transform_integration..sbs"syyBrp)rr~r:rDr'rZerorrErFrrr is_PiecewiserjrKfalselistrsortrr)frrsimplifyFcondrrrrconds2rrrrr{s `` @@rnrbrbs c AuuZ!C1I+1661::67A 55?2113E3EqvvMM >>ffQiGAtuuX=>~(1 7!]1  7E 7:A!A$gg#A$a&8&88:F: "6adaggo!66  !E  JJ/J0  1XFAs  1a #S!Q' QVVAr]H -s1vz#c(7K KK- 8:7s9G:G?*G? H'Hct|ts|S|j|x}|jS|j}|j Dcgc]}t ||}}||Scc}w)a This is an internal helper function that traverses through the epression tree of `f(t)` and collects arguments. The purpose of it is that anything like `f(w*t-1*t-c)` will be written as `f((w-1)*t-c)` such that it can match `f(a*t+b)`. )rras_polyas_exprrmrj_laplace_deep_collect)rrrrmr#rjs rnrr*si a  YYq\&yy{ 66D56VV .dcoTs,Q22rpz&_laplace_build_rules is building rulesrrarg?))rr rurrrr:r'r$rLrMrr;r>r#rr/r=r@rBr!r8rAr( EulerGammar?r3r"r*r4r<r2r+r)r-r7Halfrr6r9r,) r{rrrrrrlaplace_transform_rulesrs @rn_laplace_build_rulesr;s $ c A c A S1#A S1#A S1#A uqc "C 1# &E2 34y AaC  y AaCE C1QKA. CAqAv AE16 2 3  S "y AaCE AaD CAqAv AE16 2 3  S " y 1Q3q5 3r!tAv;q= QUAE AFFC )y 1Q3q5 Ac1"Q$q&kM1, QUAE AFFC )y 1Q3q5 1Q3 QUAF QVVS *y 1Q3q5 1 QUAE AFFC )y" AadF  #y& AaCES!Aa[LQBqDF+A- S1X QVVS *'y* 4!A;QrT!V S1QZ/T!A#a%[0AA!C S1X QVVS *+y. A#a%AaD57  1!uQw<2a46QqT!V,,S1QZ7$tAaCE{:KKAM M S1X QVVS */y4 a!A#RT 2d1g:c!A#h#6tD1I#FF SVr 1663 (5y8 Ad1gIC !2a!A$q&k>#ac(#:4QqS ?#J  9y< AuQqSz!ac(" R =y@ A#a%!Z!QqSU+C1QK7AaC@B QVSQqS]R' (!&&# 7AyD AqsQT%!*_ZAaC%88 QVSQ[2% & 5EyH QqSWsC4y!A# A IyL 3qs3w<cTAaC!8+ A MyP Ac!A#hac AaC1Q3</ ARUC !QyT aR1WtBqDF|C1QqM1$qac{2CC AAFFC !UyX 3r!Q$w< AaC48QqSAaDFO+A-d1T!A#Y;.?? ? AAFFC !Yy^ aRTAd1Q3iK1T!A#Y; 77 A!QVVS "_yb aaRT  1aR1W q4!9} -c"T!A#Y,.? ? A!QVVS "cyh aRT47 DAJs2d1Q3i<'88 A!QVVS "iyl aRTAd1gI RT 3r$qs)|+< < AAFFC !myp Ac1"Q$iAaCAaC7++GAaC4!9,EE AAFFC !qyt RQqS \  RbdA1aL(QqS1DacOC C SVr 1663 (uyz RQqS \ 47 "RTQqT!V$4S1X$=d4!9o$M SVr 1663 ({y~ aRQBZ!qb'*Q"22  yB aRAYAj!Q// AAFFC !CyF QqSCALL)!+A-..q0 Q GyJ QqsUc!A#hYq[QBqD) SVr 1663 (KyN QqSUc!fS1QZ\!^Br!tH44a79 QUCAK"$ %qvvs 4OyR QQ$r!t*S1S->)>%??  SyV Ac!feAaCjaRT*GAaCLQ,?@ AQVVS "WyZ QqS1s3q||,Q.q0114RU1W!3 (kyn U1WqA  tAeGAI qQqz!Q$%6!779 9 3r%y>!3 (oyt QtAaCy[ 41:a<Q/QBqD 9  uyx QtAaCy[ ! RD1I.  yy| U1Wq!Q$uax-( RY &}y@ U1Wq1a4%( ?QT!E1H*_=a? 3r%y>!3 (AyD aQtAaCy[! !48A:a1Q4%'l#:AacE#B3r!t9#L  EyH QtAaCy[ $q' !41:c1"Q$i#7  IyL QqS#ac( AaCE!GQT1Q3(]3QT1Q3(]C RUC1J& -MyP QqS#ac( Aq!tAqDyA~.1acAX >1acAX N RUC1J& -QyT QqS#ac( Aq!tAqDyA~.1acAX >1acAX N RUC1J& -UyX acAq!tAqDyM RUS "Yy\ acAq!tAqDyM RUS "]y` acAqAvq!tAadF1H}- 3r!u:s $ayd acA1Qq!tV ad1QT6!8m4 3r!u:s $eyh ac1c1Q31+&q( RUS "iyl Ad1Q3iqsA!r!t}acaRT]'BC RQ myp Ad1Q3iqsA!r!t}acaRT]'BC RQ qyt aQqS k DAJqLa0QqS9  uyx aQqS k AaCRT 1 T!W 4S1X =c$qs)n LL  yy~ GD4!9% % 1aLadU1W %qs1u - !H ac^ $$%!QKB$7 8 FFAFFC  !}yF aaQqS k" "B1aLadU1W$=qs1u$Ec!A#h$N  GyJ aQqS k 47 " ad1fa1Q4%'l "3qs8 +c$qs)n < FFAFFC !KyP aQqS k 47 "B1aLadU1W$=c!A#h$F  QyT d1Q3i! DG #R!A$q&\!^A1aL%@#ac(1*%M  UyX d1Q3i! DG #R!A$q&\!^A1aL%@#ac(1*%M  Yy\ QqS3q!tQqS1H}%d1ac7m3A5 3s1v; QVVS *]y` T!A#Yaac*1, QVVbeV$c +ayd QqS#d1Q3i. $q'$q'/1Q3"7 QVVRU#S *eyh T!A#Yq[ Ac4!9*o-q0 AAFFC !iyl d1Q3i4!9T!W,d1Q3i79 "Q% myp QqS$tAaCy/ !1aQqS k?  qyt d1Q3ik Cac OA- AAFFC !uyx AaC!Q$QT!Q$Y41QT ?1BQ0F FG ASAZ &yy| Aga1o  Ad2huQqvvX &q!t +QT!Q$Y1"QVV),D D RUaffW_bAh 'RUS :}yB Aga1o  QqS$r( 51Q46? *1a4 / 11a4191Q46 2J J RURZAqs $c"Q%j# 7CyH Ad1Q3iK #qbd)A+  IyL Q1T!A#Y;' 'QqS!qbd));C1I)E RURZAqx )1663 8MyP Ad1a4!8n$ % QqS41QT ?" " #DAadO 3 SVr 3r!u:s ,QyV AaC!Q$QT!Q$Y41QT ?1BQ0F FG ASAZ &WyZ Aga1o  Ad2huQqvvX &q!t +QT!Q$Y1"QVV),D D RUaffW_bAh 'RUS :[y` Aga1o  QqS$r( 51Q46? *1a4 / 11a4191Q46 2J J RURZAqs $c"Q%j# 7ayf Q1T!A#Y;' 'QqS!qbd));C!H)D RURZAqx )1663 8gyj AaC"R%ac *41QT ?: RUS "kyn AaC#q41QT ?2A56QT!Q$YH "Q% oyt #Aq ((rpctd|g}tdd}|j|}|r||jdj |}|j||z}|r[||j rL||dk7rDt dtd||z ||j|z||||z d \}} } || | fSy ) z This function applies the time-scaling rule of the Laplace transform in a straight-forward way. For example, if it gets ``(f(a*t), t, s)``, it will compute ``LaplaceTransform(f(t)/a, t, s/a)`` if ``a>0``. rrgra)nargsrz rule: time scaling (4.1.4)FrN) r rrrjcollectrru_laplace_transformrm) rrr{rrma1r#ma2rprcrs rn_laplace_rule_timescalers S1#AS"A ''!*C !fkk!n$$Q'cii!n 3q6%%#a&A+ 4 5*#a&QQ'Ac!fHuFIAr2r2;  rpctd|g}td}td}|jt||zx}r<||j||z x}r||jrOt dt ||j ||||z||d\}} } t|| |z|z| | fS||jr&t dt ||||d\}} } || | fS||j||z x}rw||jr;t d t d t|||z z ||z||d\}} } || | fS||jrt d d d tjfSy )a This function deals with time-shifted Heaviside step functions. If the time shift is positive, it applies the time-shift rule of the Laplace transform. For example, if it gets ``(Heaviside(t-a)*f(t), t, s)``, it will compute ``exp(-a*s)*LaplaceTransform(f(t+a), t, s)``. If the time shift is negative, the Heaviside function is simply removed as it means nothing to the Laplace transform. The function does not remove a factor ``Heaviside(t)``; this is done by the simple rules. rrrrz rule: time shift (4.1.4)Frz8 rule: Heaviside factor; negative time shift (4.1.4)z rule: Heaviside window openraz" rule: Heaviside window closedrN) r rr;rrurrr' is_negativerr) rrr{rrrrrrrrs rn_laplace_rule_heavisider*s S1#A S A S AggilQ&''s'a&,,q1u% %3 %1v!!67.FKK1s1v:.1uF 2rSVGaK(1,b"551v!!NP.s1vq!eL 2r2r{"a&,,q1u% %3 %1v!!9:.1s1v:..#a&8!QP 2r2r{"1v!!;<1aff~% rpcPtd|g}td}td}|jt||z}|rc||j|j||z}|r;t dt ||||||z d\}} } || t ||z| fSy) a If this function finds a factor ``exp(a*t)``, it applies the frequency-shift rule of the Laplace transform and adjusts the convergence plane accordingly. For example, if it gets ``(exp(-a*t)*f(t), t, s)``, it will compute ``LaplaceTransform(f(t), t, s+a)``. rrrzz$ rule: multiply with exp (4.1.5)FrN)r rr'rrurr!) rrr{rrrrrrrrs rn_laplace_rule_expr Ts S1#A S A S A ''#a&( C !fnnQ%%ac*  9 :*3q61aAh49;IAr2r"SV*}b) ) rpc ^td|g}td|g}td}td}|jt||z}|rQ||jts8||j |j||z|z }|rt d||||z } t | dk\rt| dk(rt|| ||z |z||z} | jttr#| jtj} | jD cgc]} | j|||||z c} \} } | dk7r*| | z ||z t j"t j$fSydt j"t j$fS||j'|rt)|||}|ik7rt+|j-d hk(rt/|||}t1t3|j5D cgc]V} t| dk(rFt | dk\r8t| |z||j||z|j|| z Xc} }|t j"t j$fSycc} wcc} w) z If this function finds a factor ``DiracDelta(b*t-a)``, it applies the masking property of the delta distribution. For example, if it gets ``(DiracDelta(t-a)*f(t), t, s)``, it will return ``(f(a)*exp(-a*s), -a, True)``. rrrrrz# rule: multiply with DiracDeltarNra)r rr:r~rrur!r"r'r3r2rewriter5ratsimpas_numer_denomrrrr is_polynomialrQsetvaluesrrrkeys)rrr{rrrrrrlocfnrrrroslopers rn_laplace_rule_deltarksY S1#A S1#A S A S A ''*Q-/ "C 3q6::j)!fnnQ%%ac!e,  8 9a&Q-C#w!|31 #a&Q)*3q6166#s#D)113B:<:K:K:MNQq#a&Q-0N16aCAJ(:(:AFFCC1--qvv66 q6   "s1vq!BRxC ,3SVQ#BGGIM"Q%1*A!1"Q$iA Aq 11%**Q2BBMN1--qvv66 OMs 7"J%$AJ*c:tjg}tjg}tj|D]N}|j t t tttr|j|>|j|Pt|}t|}||fS)z Helper function for `_laplace_rule_trig`. This function returns two terms `f` and `g`. `f` contains all product terms with sin, cos, sinh, cosh in them; `g` contains everything else. ) rOner make_argsr~r3r2r+r)r'append)rtrigsothertermrrs rn_laplace_trig_splitrs{UUGE UUGE b! 88CdD# . LL  LL   U A U A a4Krpctd|g}td|g}td|g}g}g}|jtj}t j |D]}|j |s"|jd|ddtdtdi6t|jd |}|j|t||z|zzx} O|jd| |t| |zd| |tt| |tt| |i|j|||fS) a Helper function for `_laplace_rule_trig`. This function expects the `f` from `_laplace_trig_split`. It returns two lists `xm` and `xn`. `xm` is a list of dictionaries with keys `k` and `a` representing a function `k*exp(a*t)`. `xn` is a list of all terms that cannot be brought into that form, which may happen, e.g., when a trigonometric function has another function in its argument. c1rc0rkrrr')combine) r r r'r rrr~rr!r"rpowsimpr) rrr r!rxmxnx1rrs rn_laplace_trig_expsumr(s+ dQC B dQC B S1#A B B 3   B b! xx{ IIsD#q"aQ7 8 $T\\%\%@!DAc"Q$r'lN+ +A 8 IIQqT#ae*_c1R5BquIr2ae9. / IIdO  r6Mrpc g}g}dfd}fd}fd}fd}d} t|dkDr|j} d} d} d} tt|D]}| t||tk(}| t||t k(}| t||tk(}| t||t k(}|r|r| tdk7r| tdk7r|} ||r|r| tdk7r|} |s|s| tdk7s|} | | | |j || || d || d || d ||j t t| d | | | g}|jd |D]}|j|n#| I|j || || d ||j | t|j| n| R|j || || d ||j t | t|j| n| R|j || || d ||j t | t|j| n0|j | | ||j | tt|dkDrt|t|fS) a Helper function for `_laplace_rule_trig`. This function takes the list of exponentials `xm` from `_laplace_trig_expsum` and simplifies complex conjugate and real symmetric poles. It returns the result as a sum and the convergence plane. c6|j}tt|D]q}||j}|dj t r||j t||<J|dt|dzzj t||<s|Sr) copyrangelenrr~r"r r2r)coeffsncr"ris rn_simpcz"_laplace_trig_ltex.._simpcs [[]s2w 7AA##%B!uyy}1 c*1A2a511#61  7  rpc |d|d|t|tf\}}}}||z|z|z|||z|z |z zdtz|z|zz dtz|z|zz|dz| |z |z |z z|dtz|z|zdtz|z|zzzzd|dzz|zzd|dzz|zz|dz| |z |z|zz|dzdtz|z|zdtz|z|zzdtz|z|zz dtz|z|zz zz|d|dzz|zd|dzz|zz zzg} tjtj d|dzzd|dzzz tj |dzd|dzz|dzzz|dzzg} t t| tt| dddD cgc] \} } | || zzc} } } t t| tt| dddD cgc] \} } | || zzc} } }| |z Scc} } wcc} } w)Nrr"rrrr) r!r"rrrrrzipr,r-)t1k1k2k3r{rk0a_ra_ir/dcrrrrr1s rn _quadpolez%_laplace_trig_ltex.._quadpolesfS'2c7BrFBrF:2sC GbL2  rBw|b !AaCGBJ .1S ;1rcBhmb()1Q3s72:!C *+,#q& Qhrk*1rcBhmb()1ac#gbj1Q3s72:-!C :QqSWRZGHI1S!V8B;36",-.   EE1661S!V8aQh. FFCFQsAvXc1f_,sAv57 !$VBZs2w"1E!F GAa1f G I !$Rs2w")=!> ?Aa1f ? As H ?s "H %H c |d|d|t|tf\}}}}||z| |z||zz dtz|z|zzg}tjd|z|dz|dzzg}t t  |tt|dddD cgc] \} } | || zzc} } } t t |tt|dddD cgc] \} } | || zzc} } } | | z Scc} } wcc} } wNrr"rrr r!r"rrrrr3r,r-)r4r5r{rr8r9r:r/r;rrrrr1s rn_ccpolez#_laplace_trig_ltex.._ccpolesS'2c7BrFBrF:2sC2gr"uqt|ac#gbj0 1eeRVS!Vc1f_ - !$VBZs2w"1E!F GAa1f G I !$Rs2w")=!> ?Aa1f ? As H ?s C2 C8 c  |d|d|t|tf\}}}}||z||z||zz dtz|z|zz g}tjdtz|z|dz |dzz g}t t  |tt|dddD cgc] \} } | || zzc} } } t t |tt|dddD cgc] \} } | || zzc} } } | | z Scc} } wcc} } wr>r?)r4r6r{rr8r9r:r/r;rrrrr1s rn_rspolez#_laplace_trig_ltex.._rspoles S'2c7BrFBrF:2sC2gqtad{QqSWRZ/ 0eeRT#XQwa/ 0 !$VBZs2w"1E!F GAa1f G I !$Rs2w")=!> ?Aa1f ? As H ?s C9 C? c |d|d}}||z|||z zg}tjtj|dz g}tt  |t t |dddDcgc] \}}|||zzc}}} tt |t t |dddDcgc] \}}|||zzc}}} | | z Scc}}wcc}}w)Nrr"rr)rrrrr3r,r-) r4r7r{rr8r/r;rrrrr1s rn_sypolez#_laplace_trig_ltex.._sypole s3C22gq"r'{ #eeQVVadU # !$VBZs2w"1E!F GAa1f G I !$Rs2w")=!> ?Aa1f ? As H ?s 0C 3C c.|d|d}}|}||z }||z S)Nrr"rq)r4r{rr8rrs rn _simplepolez'_laplace_trig_ltex.._simplepoles*3C2  Es rprNr"rT)reverse) r-popr,r!r"rr$rrr-)r%rr{resultsplanesr<r@rBrDrFr4 i_imagsym i_realsym i_pointsymireal_eqrealsymimag_eqimagsymindices_to_popr1s @rn_laplace_trig_ltexrTsG F. b'A+ VVX   s2w Af1b )GfAr *Gf1b )GfAr *G7r"v{r"v{ WB1 WB1  (%)*?* NN"Y-,bmC.@Z.-q2 3 MM#bCk* +(J?N     -# q    " NN72r)}S'91= > MM"R& ! FF9   " NN72r)}S'91= > MM#bf+ & FF9   # NN72r*~c':A> ? MM#bf+ & FF:  NN;r1- . MM"R& !q b'A+t =#v, &&rpc dtdd}|jtttt syt |j||\}}t||\}}t|dkDry|j|s&t|||\}} ||z| tjfSg} g} t|||d\} } }|D]O}| j|d| j|||d z z| j| t|d zQt!| j||t#| |fS) z This rule covers trigonometric factors by splitting everything into a sum of exponential functions and collecting complex conjugate poles and real symmetric poles. rTrealNrFrr"r)rr~r3r2r+r)rrr(r-rTrrrrr!rr-)rt_r{rrrr%r&rrrJrIGG_planeG_condr's rn_laplace_rule_trigr\Ys# cA 66#sD$ ' rwwr1~ .DAq !!Q 'FB 2w{ 558!"a+1sAqvv~/1a%H7F /B NN2c7166!Qr#wY#77 8 MM'"RW+- . / =  a $c6lF ::rpctd|g}td|g}td}|j|t|||fz}|r||jr||j Dcgc]}|j |}}t|dk(rtdg} t||D]^} | dk(r||j|d} n!t|||| fj|d} | j|||| z dz z| z`t||||d \} } }|||||z| zt| z z| |fSy cc}w) a  This function looks for derivatives in the time domain and replaces it by factors of `s` and initial conditions in the frequency domain. For example, if it gets ``(diff(f(t), t), t, s)``, it will compute ``s*LaplaceTransform(f(t), t, s) - f(0)``. rrrrraz" rule: time derivative (4.1.8)rFrN)r rrr is_integerrjr~sumrur,rrrr)rrr{rrrrrrrr"rrrrs rn_laplace_rule_diffr`zsV S1#A S1#ASA ''!Jq1a&)) *C s1v  "1v{{ +!QUU1X + + q6Q; 7 8A3q6] ,6A Aq)A"3q6Aq62771=ASVAXaZ*+  , +3q61a%HIAr2FAs1vIaK#q'12R< <  ,s*Ec |jrdg}dg}tj|D]6}|j|r|j |&|j |8t |dkDr4t |}t||j}t |}|dkDrt |} t| ||d\} } } | g} d} t| d| }| jtr)+<$$&9;J 1a A -H rpct\}}}d}d}|D]\}} } } } || k7r| |j||i}| }|j|} | s= | j| }|t j k(sc| j| j||i| j| t j fcSy#t$rYwxYw)zj This function applies all simple rules and returns the result if one of them gives a result. N)rrrxreplacerrr)rrr{ simple_rulesrXrprep_oldprep_ft_doms_domcheckplaneprepmars rn_laplace_apply_simple_rulesrs 01L"bH F,84(ueUD t !&&!R/*FH \\%   NN2& AFF{r*//Q8r*AFF444   sB>> C  C cR|js;tdd}t|j||i|j||iSt |}g}|j D]\}}t |tr]||j vrOt |ttfr|cS|jt|j|jz |ztt |trst|j dk(r[|j D]K}|j |k(r5|jt|j|jz |zG|ccSt |t"rt|j dk(r|j \}}|j |k(rz|j |k(rkd|j$vr||}}|jt|j|jz t|j|jz z |z|cS|cSt'|S)z This function converts a Piecewise expression to an expression written with Heaviside. It is not exact, but valid in the context of the Laplace transform. rTrVr>)is_realr_piecewise_to_heavisiderr1rjrrrrrr;gtsrrLr-lhsrMrr) rrrrrrc2r!r s rnrrs 99 #D !&qzz1a&'91=FF1vNNAA AFF D dJ 'AN$R) 488dhh#67:; b !c$))n&9ii 66Q;HHYrvv7:;H   c "s499~':YYFBvv{rvv{"))#Brvv/rvv/01345HA B 7Nrpc jtd}td}td}td}t|tr*|jts|jt s|S|j D]\}}|jt ||||x}||||k(r |||cS|jt |||||x} i||||k(su|||cS|j} |jD cgc]} t| |} } | | Scc} w)a This helper function takes a function `f` that is the result of a ``laplace_transform`` or an ``inverse_laplace_transform``. It replaces all unevaluated ``LaplaceTransform(y(t), t, s)`` by `Y(s)` for any `s` and all ``InverseLaplaceTransform(Y(s), s, t)`` by `y(t)` for any `t` if ``fdict`` contains a correspondence ``{y: Y}``. Parameters ========== f : sympy expression Expression containing unevaluated ``LaplaceTransform`` or ``LaplaceTransform`` objects. fdict : dictionary Dictionary containing one or more function correspondences, e.g., ``{x: X, y: Y}`` meaning that ``X`` and ``Y`` are the Laplace transforms of ``x`` and ``y``, respectively. Examples ======== >>> from sympy import laplace_transform, diff, Function >>> from sympy import laplace_correspondence, inverse_laplace_transform >>> from sympy.abc import t, s >>> y = Function("y") >>> Y = Function("Y") >>> z = Function("z") >>> Z = Function("Z") >>> f = laplace_transform(diff(y(t), t, 1) + z(t), t, s, noconds=True) >>> laplace_correspondence(f, {y: Y, z: Z}) s*Y(s) + Z(s) - y(0) >>> f = inverse_laplace_transform(Y(s), s, t) >>> laplace_correspondence(f, {y: Y}) y(t) rr{rr) r rrr~reInverseLaplaceTransformitemsrrmrjlaplace_correspondence) rfdictrr{rrrYrrmr#rjs rnrrDs(H S A S A S A S A1d#EE*+56 1gg.qtQ:;;HaDAaDLQqT7Ngg5adAq!DEEaDAaDLQqT7N  66D:;&& A3 "3 . AD A ; BsD0c z|jD]\}}tt|D]}|dk(r|j|d|d}$|dk(r1|jt t ||||d|d}Z|jt t ||||f|d||}|S)a This helper function takes a function `f` that is the result of a ``laplace_transform``. It takes an fdict of the form ``{y: [1, 4, 2]}``, where the values in the list are the initial value, the initial slope, the initial second derivative, etc., of the function `y(t)`, and replaces all unevaluated initial conditions. Parameters ========== f : sympy expression Expression containing initial conditions of unevaluated functions. t : sympy expression Variable for which the initial conditions are to be applied. fdict : dictionary Dictionary containing a list of initial conditions for every function, e.g., ``{y: [0, 1, 2], x: [3, 4, 5]}``. The order of derivatives is ascending, so `0`, `1`, `2` are `y(0)`, `y'(0)`, and `y''(0)`, respectively. Examples ======== >>> from sympy import laplace_transform, diff, Function >>> from sympy import laplace_correspondence, laplace_initial_conds >>> from sympy.abc import t, s >>> y = Function("y") >>> Y = Function("Y") >>> f = laplace_transform(diff(y(t), t, 3), t, s, noconds=True) >>> g = laplace_correspondence(f, {y: Y}) >>> laplace_initial_conds(g, t, {y: [2, 4, 8, 16, 32]}) s**3*Y(s) - 2*s**2 - 4*s - 8 rra)rr,r-rrr )rrrricr"s rnlaplace_initial_condsrsDK2s2w KAAvIIadBqE*aIId:adA#61=r!uEIId:adQF#;QBBqEJ  KK Hrpctj|}g}g}g}g}|D]} | jd\} } | jtr\tj| j t } | D].} | jd\}}|j| |z|f0| jtk(rn| jtsTtjt| } | D].} | jd\}}|j| |z|f0 |j| | f!|D]l\} } | jtrt| |tjdf}n| jt r5| jts| jt d} t!| |x} t#| |x} t%| |x}nwt'fd| j)t*Drt| |tjdf}n1t-| ||x} nt| |tjdf}|\}}}|j| |z|j||j|ot|}|r|j/d}t1|}t3|}|||fS)z Front-end function of the Laplace transform. It tries to apply all known rules recursively, and if everything else fails, it tries to integrate. Fas_AddTrac3@K|]}|jywrr~)rundefrXs rnrz%_laplace_transform..sGuUYYr]Grdoit)rras_independentr~rCr r;rrmr0r:rrerrrrr|rwanyrr rbrr-rM)rrXrrterms_tterms_stermsrJ conditionsffr"ft_terms_termr5f1rri_pi_ci_rlr conditions ` rnrrsmmBGG E FJ "!!"U!32 66% &]]2::i#89F )--b-?B adBZ( )WW !"&&B*@]]#:2r#BCF )--b-?B adBZ( ) LL!R ! "2 66% &!"b"-q/A/A4HAvvim$RVVJrN-CWWYr]A.5b"bAAQ 3BB??Q )"b"55QBG0FGG&b"b113E3EtL5B33!;?@%b"b113E3EtLc3qu c#;>']Fe, LEZ I 5) ##rpc&eZdZdZdZdZdZdZy)rea Class representing unevaluated Laplace transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute Laplace transforms, see the :func:`laplace_transform` docstring. If this is called with ``.doit()``, it returns the Laplace transform as an expression. If it is called with ``.doit(noconds=False)``, it returns a tuple containing the same expression, a convergence plane, and conditions. Laplacec H|jdd}t||||}|S)NrFr)getrb)selfrrr{hintsrFLTs rn_compute_transformz#LaplaceTransform._compute_transforms'IIj%0 +Aq!i H rpcxt|t| |zz|tjtjfSr)rEr'rrr)rrrr{s rn _as_integralzLaplaceTransform._as_integrals,#qbd) a%<==rpc |jdd}|jdd}td|j|j|jf|j}|j}|j}t ||||}|r|dS|S)j Try to evaluate the transform in closed form. Explanation =========== Standard hints are the following: - ``noconds``: if True, do not return convergence conditions. The default setting is `True`. - ``simplify``: if True, it simplifies the final result. The default setting is `False`. nocondsTrFz[LT doit] (%s, %s, %s)rr)rrXfunctionfunction_variabletransform_variabler)rr_nocondsrFrXrrrs rnrzLaplaceTransform.doit s99Y-IIj%0 '$--*.*@*@*.*A*A*C D # #  $ $ ]] r2rI > Q4KHrpN)ri __module__ __qualname____doc___namerrrrqrprnreres  E >rprec jdd}jdd}t|trt|drʉjdd }|rA|r?d}t dd|t t 5|jfd cd d d S|D cgc]} t| fi} } |r:t| \} } } t|g|j| }|t| t| fSt|g|j| St|jd| \}}}|s|||fS|S#1swY4xYwcc} w) a Compute the Laplace Transform `F(s)` of `f(t)`, .. math :: F(s) = \int_{0^{-}}^\infty e^{-st} f(t) \mathrm{d}t. Explanation =========== For all sensible functions, this converges absolutely in a half-plane .. math :: a < \operatorname{Re}(s) This function returns ``(F, a, cond)`` where ``F`` is the Laplace transform of ``f``, `a` is the half-plane of convergence, and `cond` are auxiliary convergence conditions. The implementation is rule-based, and if you are interested in which rules are applied, and whether integration is attempted, you can switch debug information on by setting ``sympy.SYMPY_DEBUG=True``. The numbers of the rules in the debug information (and the code) refer to Bateman's Tables of Integral Transforms [1]. The lower bound is `0-`, meaning that this bound should be approached from the lower side. This is only necessary if distributions are involved. At present, it is only done if `f(t)` contains ``DiracDelta``, in which case the Laplace transform is computed implicitly as .. math :: F(s) = \lim_{\tau\to 0^{-}} \int_{\tau}^\infty e^{-st} f(t) \mathrm{d}t by applying rules. If the Laplace transform cannot be fully computed in closed form, this function returns expressions containing unevaluated :class:`LaplaceTransform` objects. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. If ``noconds=True``, only `F` will be returned (i.e. not ``cond``, and also not the plane ``a``). .. deprecated:: 1.9 Legacy behavior for matrices where ``laplace_transform`` with ``noconds=False`` (the default) returns a Matrix whose elements are tuples. The behavior of ``laplace_transform`` for matrices will change in a future release of SymPy to return a tuple of the transformed Matrix and the convergence conditions for the matrix as a whole. Use ``legacy_matrix=False`` to enable the new behavior. Examples ======== >>> from sympy import DiracDelta, exp, laplace_transform >>> from sympy.abc import t, s, a >>> laplace_transform(t**4, t, s) (24/s**5, 0, True) >>> laplace_transform(t**a, t, s) (gamma(a + 1)/(s*s**a), 0, re(a) > -1) >>> laplace_transform(DiracDelta(t)-a*exp(-a*t), t, s, simplify=True) (s/(a + s), -re(a), True) There are also helper functions that make it easy to solve differential equations by Laplace transform. For example, to solve .. math :: m x''(t) + d x'(t) + k x(t) = 0 with initial value `0` and initial derivative `v`: >>> from sympy import Function, laplace_correspondence, diff, solve >>> from sympy import laplace_initial_conds, inverse_laplace_transform >>> from sympy.abc import d, k, m, v >>> x = Function('x') >>> X = Function('X') >>> f = m*diff(x(t), t, 2) + d*diff(x(t), t) + k*x(t) >>> F = laplace_transform(f, t, s, noconds=True) >>> F = laplace_correspondence(F, {x: X}) >>> F = laplace_initial_conds(F, t, {x: [0, v]}) >>> F d*s*X(s) + k*X(s) + m*(s**2*X(s) - v) >>> Xs = solve(F, X(s))[0] >>> Xs m*v/(d*s + k + m*s**2) >>> inverse_laplace_transform(Xs, s, t) 2*v*exp(-d*t/(2*m))*sin(t*sqrt((-d**2 + 4*k*m)/m**2)/2)*Heaviside(t)/sqrt((-d**2 + 4*k*m)/m**2) References ========== .. [1] Erdelyi, A. (ed.), Tables of Integral Transforms, Volume 1, Bateman Manuscript Prooject, McGraw-Hill (1954), available: https://resolver.caltech.edu/CaltechAUTHORS:20140123-101456353 See Also ======== inverse_laplace_transform, mellin_transform, fourier_transform hankel_transform, inverse_hankel_transform rFr applyfuncz#deprecated-laplace-transform-matrixz Calling laplace_transform() on a Matrix with noconds=False (the default) is deprecated. Either noconds=True or use legacy_matrix=False to get the new behavior. z1.9)deprecated_since_versionactive_deprecations_targetc t|fiSr)laplace_transform)fijrr{rs rnrz#laplace_transform..s 1#q! Eu ErpNrr)rrrNhasattrrUrWrVrrr3typeshaper-rMrer)rrr{ legacy_matrixrrrFradtrelements_transelementsavalsr f_laplacerrrs `` ` rnrr)s~NyyE*H *e,I!Z WQ %<IIi// ]7C % */+. !!89 G{{EG G G 012(+0Q$"$2N2.1>.B+%#DG7QWW7h7  #u+sJ/???tAw88881a(--e7@.BHB1 1ax ' G G2s:D9E9Ec  ddlm}m ddlm}t dd fd}|j |r|j|}|jrKt|jDcgc]}t||||c}} t| j||dfS |||t dtj fdd \} } | g|||} | y| j$r(| jd\} } | j't(rytj*} | j-t.|} | j$r| j| fSt d tj0ffd } | j-t2| } d } | j-t| } t| j|| fScc}w#t"$rd} Y wxYw)z6 The backend function for inverse Laplace transforms. r)meijerint_inversion_get_coeff_exp)inverse_mellin_transformrTrVcJt|dk7rt|S|djdj}|\}}|djd}|djd}t dt |z |zz |zt |zdt |z z |zzS)z3 Simplify a piecewise expression from hyperexpand. rrrra)r-r0rjargumentr;r$)rjr#coeffexponente1e2rrs rnpw_simpz7_inverse_laplace_transform_integration..pw_simps t9>d# #1gll1o&&(a0x !W\\!_ !W\\!_ aE lQ[0 1" 4 akAc%jL0 1" 4 5 6rpNF)needevalrucL|jt }|jr t||Sddlm}||dkD}|j k(r$t|j}t|z|St|j }t|z |S)Nrr) rr'r~r;rrrr(r)r#H0rrrelr"rrs rnsimp_heavisidez>_inverse_laplace_transform_integration..simp_heavisides CHHS!Wa  558S"% %@Aq) 77a<CGG AQUB' 'CGG Aq1uXr* *rpc*tt|Sr)r r')r#s rnsimp_expz8_inverse_laplace_transform_integration..simp_expsc#h''rp)sympy.integrals.meijerintrrsympy.integrals.transformsrris_rational_functionapartrvrrjrcrFrr'rrrHrr~rErrr0rr;)rr{rXrrrrrXrrrrrrrs @@@rnrcrcsNC cA 6 a GGAJxx vv5Q1eXN 21477*1aaR4:L48%I4  y 1a ( 9 >>ffQiGAtuuX66D IIi )~~vva}d"" c A vv + )^,A( #x A QVVAr]H -t 33c " s&G+G GGcddlm}||\}}|j|rV|j|j }t |dk(r)|\}}}|||d|zz zdz||z z|d|zz dzz z}||z S)Nr)fractionrr)rrrrrcr-) rr{rrrcfrrrs rn_complete_the_square_in_denomr s/ a[FQq YYq\ $ $ & r7a<GAq!Aa1gI>!A#%q!A#wl23A Q3Jrpc td}td}td|g}td|g}td|g}tdd}d }||z |tj|d f|||z| zz||d z zt | |zzt |z tj|d fd |d z|d zzd zz t||z||zt||zzz d |d zzz tj|d fd ||zz ||d z zt |z tj|d fd |||z|zzz t|||z||zt |zz tj|d fg}|||fS) z This is an internal helper function that returns the table of inverse Laplace transform rules in terms of the time variable `t` and the frequency variable `s`. It is used by `_inverse_laplace_apply_rules`. r{rrrrrz._inverse_laplace_build_rules is building rulescH |j|S#t$r|cYSwxYwr)factorrP)rr{s rn_fracz+_inverse_laplace_build_rules.._frac&s) 88A;  H s  !!c|Srrq)rs rnsamez*_inverse_laplace_build_rules..same,srprarr) rr rurrr'r@r3r2rA)r{rrrrrr _ILT_ruless rn_inverse_laplace_build_rulesrs c A c A S1#A S1#A S1#A ;<  1aq! qsqbkM1qs8C1I-eAh6 FFD!  AqDAI> C!Hqs3qs8|3a1f= q  AqD1q1u:eAh&a8 AqsQhJAqs+QT%(]; q J q! rpc8|dk(r&tdt|tjfSt \}}}d}|j ||i}|D]\}} } } } || | fk7r| || z} | | f} j |}|s3| }|tjur)|dDcgc]}|j|}}|d|}|tjk(st|| j|j ||iztjfcSycc}w)@ Helper function for the class InverseLaplaceTransform. raz rule: 1 o---o DiracDelta()r~rN) rur:rrrrrrr;)rr{rrrrX_prepfsubsrrrrrh_Frrrrjs rn#_inverse_laplace_apply_simple_rulesr@s  Av01!}aff$$57JB E FFAr7OE*4 M&ueT3 T3K eCiB3KE XXe_ A01!51 255AaD$KAFF{ |ENN2$6$;$;RG$DDaffLL M  6sDctd|g}td|g}td}|j|t|||fz}|r?||jr0t dt |||||dd\}} | ||z|z| fSy) rrrrrz3 rule: t**n*f(t) o---o (-1)**n*diff(F(s), s, n)Fr dorationalN)r rr r^ru_inverse_laplace_transform) rr{rrrrrrrrs rn_inverse_laplace_diffr]s S1#A S1#A S A :a!Q(( )B beDE) qE1a5B1RU{1}a rpctd|g}td}|j|s|t|ztjfS|jt sy|j t ||z}|rY||jr,tdt|||ztjfSt||||tjfS|j t ||z|z}|rR||jr%tdt||||||z|dd St||||tjfSy) rrrrNz* rule: exp(-a*s) o---o DiracDelta(t-a)z5 rule: exp(-a*s)*F(s) o---o Heaviside(t-a)*f(t-a)FTr) r r~r:rrr'rrrurr)rr{rrrrrs rn_inverse_laplace_time_shiftrns* S1#A S A 558A&& 55: ''#ac( C q6   ? @aAh'/ /*1aE:AFFB B ''#ac(1* C q6   J K-A1SV8UUtM M+1aE:AFFB B rpc|j|s|t|ztjfSt |j x}dk(rt d|g}|dj||z x}rct||jrKtdt|| |zt|j||||ztjfSy)rrarrrz& rule: F(s-a) o---o exp(-a*t)*f(t)N)r~r:rrr-rjr rr!rrur'rrm)rr{rrrjrrs rn_inverse_laplace_freq_shiftr s 558A&& 166>4a qc "q'--!$ $B $"RU)*?*? ; <RUF1H 'q 1a?@ABI I rpctd|g}td}|j||z|z}|r||jr||jrt dt |||||dd\}}|j t|d}|jtrt|||||fSt|t||||z|fSy ) rrrrz+ rule: s**n*F(s) o---o diff(f(t), t, n)FTrraN) r rr^rrurrr;r~rr) rr{rrrrrrrs rn_inverse_laplace_time_diffr s S1#A S A ''!Q$q&/C s1v  SV%7%7<=) FAq%%DB1 IIilA & 55( )1c!f%q( (Q<Q3q6 22A5 5 rpc +td|g}td|gtd|g}td|gd}tj}|j}|D cgc]} | j |||zzzz!} } d| vrytj } g} g} g}| D]c}||dk(r| |z} |j r| j|2|jr| j|S|j|et| fd } t| fd  } t|dk7ryt| d k(rt| dk(r| dd k(r| d|tjk(r| d| d|z }d | d|z | z}|j r=|ttz t|z ||zt|d z|zzt|t|zzz }t!dn| ddk(r| d|tjk(r| d| d|z }|d z}d | d|d zz | z}|j r|d d ttz t|zt|zz d d |z|zz t||zzt#t|t|zd z zzz}t!dn| ddk(r| d|tjk(r| d| d|z }d | d|dzz | z}|j r|d ttz |d z|zd zzt|z||zt|d z|zzd |d zz|zdzzt|t|zzz z}t!dnB| ddk(r| d|tjk(r| d| d|z }d | d|dzz | zdz }|j r||d|dzz|d zzd|d zz|zzdzzt|d z|zzt|t|zzd ttz |dzz|tdd z zzd |d zz|zdzzz z}t!dnX| dtj k(r=| d|d k(r1t| d| d|z }d t| d|z | z}|t%d||zz}t!dnt| d k(rt| d k(r| ddk(r| d|tjk(r| dtjk(r| ddk(r| d}t| d|| d|z | z}|d |dzz|d zzd|d zz|zzd zzt|d z|zzt|t|zzd ttz |z|d z|zd zzt|zz }t!d| dd k(r| d|d k(r| dtjk(r| d|d k(r| d| d|z }| d| d|z }t| d|| d|z | z}|t| |zt|z ttz t||z t| |zzt#t||z t|zzzz}t!dnt| d k(rt| dk(r| dd k(r| d|d k(r| d tj k(r| d |d k(r| d dk(r| d | d|z }d t| d |z | d|z | z}|j r5|t|z t||zzt#t|t|zz}t!d n| dd k(r| d|d k(r| ddk(r| d d k(r| d |tjk(rt| d | d |z }d | d|z | d |z |z | z}|j rm|d t|d z|zt|t|zzz z}t!d n1| dd k(r| d|tjk(r| d tj k(r| d |d k(r| d dk(rw| d| d|z }d | d|t| d |zz | z}|j r|t|d z|zzt|t|zz}t!d nf| dtd d z k(r| d|d k(r| ddk(r| d d k(r| d |tjk(r| d | d |z }d | d|tdd z z| d |zz |d zz | z}|j r|d ttz |zt|zt|d z|zt|t|zzzd z z}t!d nl| ddk(r| d|tjk(r| d d k(r| d |d k(r| d dk(r| d| d|z }|d z}d | d|d zz | d |z | z}|j r|d |z d |zd |z z t||zztt|t|zzzd ttz t|z t|zz z}t!d  nn| ddk(r| d|tjk(r| d tj k(r| d |d k(r| d dk(r| d| d|z }d | d|d zz t| d |z | z}|j r|d ttz t|zd |z|zt|d z|zzt|t|zzz z}t!d! nx| ddk(r| d|tjk(r| d tj k(r| d |d k(r| d dk(r| d}| t| d |z | d|z }|d |d zz|zd z|zt|d z|zzt|t|zzd ttz |z|tdd z zzz z}t!d"n| dd k(r| d|d k(rt| d tj k(rY| d |d k(rM| d| d|z }| d | d |z }| t| d |z | d|z }|d t||z z t| |zzt#t||z t|zzz}t!d#nt| d k(rt| d k(r| dd k(rn| d|d k(rb| d d k(rV| d |tjk(r<| dtjk(r"| d|d k(r| ddk(r | d | d |z }|d z}| d | d|z }t| d|| d|z | d |z ||z z | z}|j r|j r||t||zztt|t|zzt|t|zt||zztt|t|zzz|t||zzz z}t!d$n!| dd k(r| d|d k(r| ddk(r| d d k(r| d |tjk(r| dd k(r| d|tjk(r| d| d|z }| d | d |z }||zdk(r| d|| d|z | d |z | z}|d t|d z|zzt|t|zzd z z}t!d%n1| d d k(r| d |d k(r | d dk(r| ddk(r| d|tjk(r| dd k(r| d|tjk(r| d| d|z }| d| d|z }||zdk(r| d|d z| d |z | d|d zz | z}|d d&|d zz|zt|d z|zzt|t|zzzd&ttz |zt|zz z}t!d'n | d d k(r| d |d k(r| d dk(r| ddk(r| d|tjk(r| ddk(r| d|tjk(r| d| d|z }| d| d|z }||zdk(rr| d|dz| d |z | d|dzz | z}|d d&|dzz|d zzd&|d zz|zzd zzt|d z|zzt|t|zzd&ttz |zt|zd |d zz|zd zzz d z z}t!d(nt| dk(rt| dk(r| dd k(r| ddk(r| d|d k(r| d d k(r| d |d k(r| d tj k(r| d |d k(r| d  | d |z }d | d|z | d |z t| d |z | z}|j r||td d z zt||zzt#t|t|zzd |z ttz t|zz z}t!d)n| dd k(r}| d|d k(rq| d d k(re| d |tjk(rK| d tj k(r0| d |d k(r$| d dk(r| d | d |z }|d z}| d | d|z }d | d|z | d |z t| d |z t|||z zz }|j r|j r|t|t||zztt|t|zzt|t||zzt#t|t|zzzt|t||zzz z}t!d*|yt'||z|fScc} w)+rrrrrrNrc&||dk7|fSrrqrrrs rnrz-_inverse_laplace_irrational..1qtqy!A$(?rprc&||dk7|fSrrqrs rnrz-_inverse_laplace_irrational..rrprarrz rule 5.3.4rz rule 5.3.10rz rule 5.3.13r rz rule 5.3.16z rule 5.3.35/44z rule 5.3.14z rule 5.3.22z rule 5.3.1z rule 5.3.5z rule 5.3.7z rule 5.3.8z rule 5.3.11z rule 5.3.12z rule 5.3.15z rule 5.3.23z rule 5.3.6z rule 5.3.17z rule 5.3.18z rule 5.3.19z rule 5.3.2z rule 5.3.9)r rras_ordered_factorsrrrrrsortedr-rr/rr'r=rur<r7r;)rr{rrrrrlrfarr constantszerospolesrestrrk_a_sqb_a_numrrs @@rn_inverse_laplace_irrationalr!s S1#A S1#A S1#A S1#A FI   B*, -Q!''1QT6!8a- -B - rzI E E D 7a<!$I !W LL  !W LL  KK  5? @E 5? @E 4yA~ 5zQ3u:? 8A;" q!!6q!U1Xa[(B58A;y(B~~tBxKQ'rE#b!eAg,&tBtAwJ'778() 1Xa[B 58A;!&8A;uQx{*DqB58A;>!)+BAd2hJtBx/Q771R463r!t9,c$r(472B.CA.EFGH)* 1Xa[B 58A;!&q!U1Xa[(B58A;>!)+B~~$r( BE!GAI.tAw61SQq\)1RU719Q;7RQZ8HHIJ)* 1Xa[B 58A;!&q!U1Xa[(B58A;>!)+A-B~~1RU71a4<2q5 2145c"a%'lBRQZ()$r( 2q5(QqT!V4aAgaikBCD)* 1Xa[QVVG #a q(8eAhqk%(1+-.B4a $$Y.B'!RT*+F ( ) UqSZ1_a r!eAhqkQVV&;a qvv%%(1+*:q!BeAhqk"58A;.y8BAb!eGAqDL2q5*1,-c"a%'l:RQZ !#$T"X:b="a%'!)#!%(1+-i7B"!AbD#bd)3Db$q'9I4JJJ$r( 48+DG345)*a r!eAhqkQVV&;a w&58A;!+;a q q!U1Xa[(B58A;>!$uQx{"33I=B~~$r( 47*"Qs2q57|+DDG,<<=>)*a r!eAhqkQVV&;a w&58A;!+;a q q!B4a ,,U1Xa[8B2q51aBE!G ,T"T!W*-==$r( 2 a!A$q&k)*+F % &a r!eAhqkQ&6a w&58A;!+;q!U1Xa[(Bq!U1Xa[(B4a ,,U1Xa[8B$r"u+ c2#a%j(T"R%[a-@)AACF % & UqSZ1_a r!eAhqkQ&6a r!eAhqkQVV&;a qvv%%(1+*:a q 8A;uQx{*DqB(1+eAhqk)BeAhqk"58A;.uQx{:BrEB9LBBNNs2a4yLd2htAw&6!77HT"X%c"Q$i/T"Xd1g5E0FFGs2a4yL!"()a r!eAhqkQ&6a q U1Xa[B%6a qvv%%(1+*:a qvv%!HQKa +Eq!U1Xa[(B%x1}1Xa[q!,U1Xa[8Bc"a%'lN447 #33A57)*a r!eAhqkQ&6a q U1Xa[B%6a qvv%%(1+*:a qvv%!HQKa +Eq!U1Xa[(B%x1}1Xa[!^E!HQK/a Q>yH"a% #b!eAg,.tBtAwJ/???d2hJrM$q')*+)*a r!eAhqkQ&6a q U1Xa[B%6a qvv%%(1+*:a qvv%!HQKa +Eq!U1Xa[(B%x1}1Xa[!^E!HQK/a Q>yHqQwq!t|Ab!eGAI-a/0RU1W=DG$%%&tBxZ]47%:Ab!eGAIaK%HIIJKL)* UqSZ1_a r!eAhqkQ&658A;!;Ka r!eAhqkQ&6a w&58A;!+;(1+eAhqk)B58A;uQx{*4a +< * W\1aAAq!t##%A2w!|ffX]9DAqAvqSAacE]C1I-==AC%Aa,1134Q7!W%%'#qbd) DAJ.!AaC%2r!t92%%)"Q$Z200#qbd) C1I-1Q3 3r!t90DSAY0NNA NN9Q<> *1aEHHHB NN2    d #M&$P']Fe, 3 # ##O% ;s  L05 L5cjtj|}g}g}|D]l} | jtr2| j  j j  } | j d\} } |r$| jrt| |||x} Ct| |x} 3t| ||x} "t| ||x} t| ||x} nxtfd| jtDrt!| ||t"j$f} n2t'| |||x} nt!| ||t"j$f} | \} }|j)| | z|j)|ot|}|r|j+d}t-|}||fS)z Front-end function of the inverse Laplace transform. It tries to apply all known rules recursively. If everything else fails, it tries to integrate. Frrc3@K|]}|jywrr)rrrs rnrz-_inverse_laplace_transform..sB52Brr)rrr~r'rrSrrr2rr%r)r'rrr rrrrcrrrM)rrrXrrrrrrrr"rrrrrlrs ` rnrr^s MM" EGJ% 88C=99R"%..055b2#>D""2e"41t88</r2ux99:!RDD72r5II-aR??72r5II  BAGGL,AB B)BE:AFFCA;r2ux99AEF (BE:AFFCA cqu#K%N']Fe,Z I 9 rpc\eZdZdZdZedZedZdZe dZ dZ dZ d Z y ) rz Class representing unevaluated inverse Laplace transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute inverse Laplace transforms, see the :func:`inverse_laplace_transform` docstring. zInverse LaplaceNonerc Z|tj}tj|||||fi|Sr)r_none_sentinelrG__new__)rrr{rroptss rnr9zInverseLaplaceTransform.__new__s0 =+::E ((aAuEEErpcL|jd}|tjurd}|S)Nr)rjrr8)rrs rnfundamental_planez)InverseLaplaceTransform.fundamental_planes( !  +:: :E rpc 4t||||jfi|Sr)rcr<)rrr{rrs rnrz*InverseLaplaceTransform._compute_transforms&5 q!T++6/46 6rpc<|jj}tt||z|z||tj tj zz |tj tj zzfdtjztj zz S)Nr) __class___crEr'r ImaginaryUnitrPi)rrr{rrs rnrz$InverseLaplaceTransform._as_integralsw NN   S1XaZ!Q)C%C"#aooajj&@"@"B C qttVAOO # % &rpc 8|jdd}|jdd}td|j|j|jf|j}|j}|j}|j }t |||||d}|r|dS|S)rrTrFz[ILT doit] (%s, %s, %s)rr)rrXrrrr<r) rrrrFrrXrrrs rnrzInverseLaplaceTransform.doits99Y-IIj%0 (4==+/+A+A+/+B+B+D E # #  $ $ ]]&& & B d D Q4KHrpN)rirrrrrr8r@r9propertyr<rrrrqrprnrrsI E6]N sBF  6&rprc jdd}jdd}t|tr#t|dr|j fdSt |j d|\}}|r|S||fS)a Compute the inverse Laplace transform of `F(s)`, defined as .. math :: f(t) = \frac{1}{2\pi i} \int_{c-i\infty}^{c+i\infty} e^{st} F(s) \mathrm{d}s, for `c` so large that `F(s)` has no singularites in the half-plane `\operatorname{Re}(s) > c-\epsilon`. Explanation =========== The plane can be specified by argument ``plane``, but will be inferred if passed as None. Under certain regularity conditions, this recovers `f(t)` from its Laplace Transform `F(s)`, for non-negative `t`, and vice versa. If the integral cannot be computed in closed form, this function returns an unevaluated :class:`InverseLaplaceTransform` object. Note that this function will always assume `t` to be real, regardless of the SymPy assumption on `t`. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Examples ======== >>> from sympy import inverse_laplace_transform, exp, Symbol >>> from sympy.abc import s, t >>> a = Symbol('a', positive=True) >>> inverse_laplace_transform(exp(-a*s)/s, s, t) Heaviside(-a + t) See Also ======== laplace_transform hankel_transform, inverse_hankel_transform rTrFrc"t|fiSr)inverse_laplace_transform)Fijrrr{rs rnrz+inverse_laplace_transform.. s1#q!ULeLrpr)rrrNrrrr) rr{rrrrrFrrs ```` rnrGrGsZyyD)H *e,I!Z WQ %<{{ LN N #1aE 2 7 7  8 +DAq!t rpc tdtg\ fdfdfd fdfd|S)zEFast inverse Laplace transform of rational function including RootSumza, b, nrc|js|S|jr|S|jr|S|jr|St |t r|St r)r~rvrbrxrrTNotImplementedError)e_ilt_add_ilt_mul_ilt_pow _ilt_rootsumr{s rn_iltz#_fast_inverse_laplace.._ilt s`uuQxH XXA;  XXA;  XXA;  7 #? "% %rpcJ|jt|jSr)rmmaprj)rLrQs rnrMz'_fast_inverse_laplace.._ilt_add- sqvvs4())rpcf|j\}}|jrt||zSr)rrbrK)rLrrrQr{s rnrNz'_fast_inverse_laplace.._ilt_mul0 s3&&q) t ;;% %tDz!!rpc|jzzz}|j|||}}}|jr5|dkr0 | dz zt||z zz|| zt| zz S|dk(rt||z z|z Str)r is_Integerr'r@rK) rLrnmambmrrrr{rs rnrOz'_fast_inverse_laplace.._ilt_pow6 s1q1 %  q58U1XBB}}aB3q5z#2hqj/12s75":3EFFQwRU8A:++!!rpc |jj}|jj\}t|jt |t |Sr)funr variablesrTpolyrrS)rLrvariablerQs rnrPz+_fast_inverse_laplace.._ilt_rootsum@ s@uuzzUU__ qvvvhd0DEFFrp)rr ) rLr{rrQrMrNrOrPrrrs ``@@@@@@@@rn_fast_inverse_laplacer_ sIiTA37GAq! & &*" ""G 7Nrp)Tr)rrgrd sympy.corerrrsympy.core.addrsympy.core.cachersympy.core.exprrsympy.core.functionr r r r r rrrrrsympy.core.mulrrsympy.core.relationalrrrrrrrrsympy.core.sortingrsympy.core.symbolrrr $sympy.functions.elementary.complexesr!r"r#r$r%r&&sympy.functions.elementary.exponentialr'r(%sympy.functions.elementary.hyperbolicr)r*r+r,(sympy.functions.elementary.miscellaneousr-r.r/$sympy.functions.elementary.piecewiser0r1(sympy.functions.elementary.trigonometricr2r3r4r5sympy.functions.special.besselr6r7r8r9'sympy.functions.special.delta_functionsr:r;'sympy.functions.special.error_functionsr<r=r>'sympy.functions.special.gamma_functionsr?r@rArB-sympy.functions.special.singularity_functionsrCsympy.integralsrDrErrFrGrHsympy.logic.boolalgrIrJrKrLrMsympy.matrices.matrixbaserNsympy.polys.matrices.linsolverOsympy.polys.polyerrorsrPsympy.polys.polyrootsrQsympy.polys.polytoolsrRsympy.polys.rationaltoolsrSsympy.polys.rootoftoolsrTsympy.utilities.exceptionsrUrVrWsympy.utilities.miscrXrerrrurrrbrrrrr rrr(rTr\r`rrrwr|rrrrrrerrcrrrrrr r r!r%r'r)r2rrrGr_rqrprnrs $ &&&%<<<&2255;IICC$IIMMIAA,,M/::EE062'&.+II' <EXv 6 6 lL lL^      U) U)p  * & &R  , ) )X  $  @ I' I'X ; ;@  8 / /d  8  "  4 , ,^9x* Z @$ @$F5(5pNb M4 M4`   % %P  8       >       ( w. w.t           4 4$ 4$n 5 5pD/DN:z*rp