gddlmZddlmZddlmZmZmZmZddl m Z ddl m Z m Z mZddlmZddlmZmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd l m!Z"m#Z#m$Z%Gdde Z&Gdde&Z!Gdde&Z'Gdde&Z(Gdde&Z)Gdde&Z*Gdde&Z+e*Z,e+Z-Gdde&Z.dS)) annotations)reduce)SsympifyDummyMod)cacheit)FunctionArgumentIndexError PoleError) fuzzy_and)IntegerpiI)Eq)gmpy)sieve) binomial_mod)Poly) factorialprodsqrtceZdZdZdZdS)CombinatorialFunctionz(Base class for combinatorial functions. c ~ddlm}||}|d}|||d||zkr|S|S)Nr)combsimpmeasureratio)sympy.simplify.combsimpr)selfkwargsrexprrs d/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/functions/combinatorial/factorials.py_eval_simplifyz$CombinatorialFunction._eval_simplifys[444444x~~# 74==F7OGGDMM9 9 9K N)__name__ __module__ __qualname____doc__r$r%r#rrs)22r%rceZdZUdZddZgdZgZded<edZ edZ ed Z d Z d Z dd ZdZdZdZdZdZdZddZdS)raImplementation of factorial function over nonnegative integers. By convention (consistent with the gamma function and the binomial coefficients), factorial of a negative integer is complex infinity. The factorial is very important in combinatorics where it gives the number of ways in which `n` objects can be permuted. It also arises in calculus, probability, number theory, etc. There is strict relation of factorial with gamma function. In fact `n! = gamma(n+1)` for nonnegative integers. Rewrite of this kind is very useful in case of combinatorial simplification. Computation of the factorial is done using two algorithms. For small arguments a precomputed look up table is used. However for bigger input algorithm Prime-Swing is used. It is the fastest algorithm known and computes `n!` via prime factorization of special class of numbers, called here the 'Swing Numbers'. Examples ======== >>> from sympy import Symbol, factorial, S >>> n = Symbol('n', integer=True) >>> factorial(0) 1 >>> factorial(7) 5040 >>> factorial(-2) zoo >>> factorial(n) factorial(n) >>> factorial(2*n) factorial(2*n) >>> factorial(S(1)/2) factorial(1/2) See Also ======== factorial2, RisingFactorial, FallingFactorial cddlm}m}|dkr4||jddz|d|jddzzSt ||)Nr)gamma polygammar,)'sympy.functions.special.gamma_functionsr.r/argsr )r argindexr.r/s r#fdiffzfactorial.fdiffUsjNNNNNNNN q==51)**99Q ! q8H+I+II I$T844 4r%)!r,r,r,r4#r7i;?ii i#r:iSi{/i!imiisXiUiP ioikiIi/LiSi}#r;z list[int]_small_factorialsc|dkr |j|Stt|g}}tjd|dzD]>}d|}} ||z}|dkr|dzdkr||z}nn|dkr||?tj|dz|dzdzD]#}||zdzdkr||$t tj|dzdz|dz}t |}||zS)N!r4r,Tr) _small_swingint_sqrtr primerangeappendr) clsnNprimesprimepq L_product R_products r#_swingzfactorial._swingds6 r66#A& &E!HH rvA)!QU33 % %!1%KA1uuq5A::JAq55MM!$$$)!a%A:: ) )J!#q((MM%(((U-adQhA>>??IV IY& &r%ct|dkrdS||dzdz||zS)Nr?r,) _recursiverN)rErFs r#rPzfactorial._recursives: q551NN1a4((!+SZZ]]: :r%cNt|}|jr |jr tjS|tjur tjS|jr|jr tjS|j }|dkrL|j s4d}tddD]!}||z}|j |"|j |dz }n\ttj|}n@t|d}||d||z zz}t%|SdSdS)Nr,1r?)r is_Numberis_zerorOneInfinity is_Integer is_negativeComplexInfinityrJr<rangerD_gmpyfacbincountrPr)rErFresultibitss r#evalzfactorial.evals7 AJJ ;# +y" +u ajz! +=+,,A2vv"4E%&F%*1b\\EE &!  # 5 < > !3t<===r%r,TNr)r&r'r(r)r3r@r<__annotations__ classmethodrNrPrcrmr|rrrrrrrrr*r%r#rr$sJ..`5555L $&%%%%''['<;;[; &+&+[&+P<"""<))) *** ***  >>>>>>r%rceZdZdS)MultiFactorialN)r&r'r(r*r%r#rrsDr%rczeZdZdZeedZedZdZdZ dZ d dZ d Z d Z d Zd S) subfactorialaThe subfactorial counts the derangements of $n$ items and is defined for non-negative integers as: .. math:: !n = \begin{cases} 1 & n = 0 \\ 0 & n = 1 \\ (n-1)(!(n-1) + !(n-2)) & n > 1 \end{cases} It can also be written as ``int(round(n!/exp(1)))`` but the recursive definition with caching is implemented for this function. An interesting analytic expression is the following [2]_ .. math:: !x = \Gamma(x + 1, -1)/e which is valid for non-negative integers `x`. The above formula is not very useful in case of non-integers. `\Gamma(x + 1, -1)` is single-valued only for integral arguments `x`, elsewhere on the positive real axis it has an infinite number of branches none of which are real. References ========== .. [1] https://en.wikipedia.org/wiki/Subfactorial .. [2] https://mathworld.wolfram.com/Subfactorial.html Examples ======== >>> from sympy import subfactorial >>> from sympy.abc import n >>> subfactorial(n + 1) subfactorial(n + 1) >>> subfactorial(5) 44 See Also ======== factorial, uppergamma, sympy.utilities.iterables.generate_derangements c|s tjS|dkr tjSd\}}td|dzD]}||dz ||zz}}|S)Nr,)r,rr?)rrVrur[)r rFz1z2ras r#_evalzsubfactorial._evalGsd 5L !VV6MFB1a!e__ / /a!eb2g.BIr%c|jrW|jr|jr||S|tjur tjS|tjurtjSdSdSN)rTrXrrrrNaNrW)rErs r#rczsubfactorial.evalTsi = "~ "#"4 "yy~~%u  ""z!  " " #"r%cV|jdjr|jdjrdSdSdSr)r1is_oddrrrs r#rzsubfactorial._eval_is_even^s< 9Q<  49Q<#> 4    r%cV|jdjr|jdjrdSdSdSrrrs r#rzsubfactorial._eval_is_integerbrr%c ddlm}td}tj|zt |z }t ||||d|fzS)Nr) summationra)sympy.concrete.summationsrrr NegativeOner)r rr!rrafs r#_eval_rewrite_as_factorialz'subfactorial._eval_rewrite_as_factorialfsY777777 #JJ M1 y|| +~~ !aC[ 9 999r%Tc ddlm}ddlm}m}t j|dzz|t tz|zz||dzdz||dzz|dzS)Nr)exp)r. lowergammar,ro) &sympy.functions.elementary.exponentialrr0r.rrrrr)r rrr!rr.rs r#rz#subfactorial._eval_rewrite_as_gammals>>>>>>OOOOOOOO a(aRU3Y7 37B8O8OO%a..!"%#b''* *r%c Fddlm}||dzdtjz S)Nr) uppergammar,ro)r0rrExp1)r rr!rs r#_eval_rewrite_as_uppergammaz(subfactorial._eval_rewrite_as_uppergammars1FFFFFFz#'2&&qv--r%cV|jdjr|jdjrdSdSdSrrrs r#_eval_is_nonnegativez!subfactorial._eval_is_nonnegativevrr%cV|jdjr|jdjrdSdSdSr)r1is_evenrrrs r# _eval_is_oddzsubfactorial._eval_is_oddzs< 9Q<  DIaL$? 4    r%Nr)r&r'r(r)rr rrcrrrrrrrr*r%r#rrs''R    W[ ""["::: **** ...r%rcHeZdZdZedZdZdZdZdZ d dZ d S) factorial2aAThe double factorial `n!!`, not to be confused with `(n!)!` The double factorial is defined for nonnegative integers and for odd negative integers as: .. math:: n!! = \begin{cases} 1 & n = 0 \\ n(n-2)(n-4) \cdots 1 & n\ \text{positive odd} \\ n(n-2)(n-4) \cdots 2 & n\ \text{positive even} \\ (n+2)!!/(n+2) & n\ \text{negative odd} \end{cases} References ========== .. [1] https://en.wikipedia.org/wiki/Double_factorial Examples ======== >>> from sympy import factorial2, var >>> n = var('n') >>> n n >>> factorial2(n + 1) factorial2(n + 1) >>> factorial2(5) 15 >>> factorial2(-1) 1 >>> factorial2(-5) 1/3 See Also ======== factorial, RisingFactorial, FallingFactorial cR|jr|jstd|jrC|jr|dz }d|zt |zSt |t |dz z S|jr)|tj d|z dz zzt | z StddS)Nz ? ">??? ! <;/aAa4)A,,.. ~~ 37(;(;;;z MAMa#gq[99Jt>> from sympy import rf, Poly >>> from sympy.abc import x >>> rf(x, 0) 1 >>> rf(1, 5) 120 >>> rf(x, 5) == x*(1 + x)*(2 + x)*(3 + x)*(4 + x) True >>> rf(Poly(x**3, x), 2) Poly(x**6 + 3*x**5 + 3*x**4 + x**3, x, domain='ZZ') Rewriting is complicated unless the relationship between the arguments is known, but rising factorial can be rewritten in terms of gamma, factorial, binomial, and falling factorial. >>> from sympy import Symbol, factorial, ff, binomial, gamma >>> n = Symbol('n', integer=True, positive=True) >>> R = rf(n, n + 2) >>> for i in (rf, ff, factorial, binomial, gamma): ... R.rewrite(i) ... RisingFactorial(n, n + 2) FallingFactorial(2*n + 1, n + 2) factorial(2*n + 1)/factorial(n - 1) binomial(2*n + 1, n + 2)*factorial(n + 2) gamma(2*n + 2)/gamma(n) See Also ======== factorial, factorial2, FallingFactorial References ========== .. [1] https://en.wikipedia.org/wiki/Pochhammer_symbol .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268, 1995. c tt|}tjus|tjur tjStjurt |S|jr|jr tjS|jrtjur tjStj ur|j r tj StjSttrWj }t|dkrtdt!fdt#t%|dSt!fdt#t%|dStjur tjStj ur tjSttrkj }t|dkrtddt!fdt#dt't%|dzdz Sdt!fdt#dt't%|dzdz S|jdkrjrjrtjSdSdSdS)Nr,0rf only defined for polynomials on one generatorc4||zSrshiftrrars r#z&RisingFactorial.eval..Qs./nr%c||zzSrr*rs r#rz&RisingFactorial.eval..Uq!a%yr%c6|| zSrrrs r#rz&RisingFactorial.eval..ds01177A2;;r%c||z zSrr*rs r#rz&RisingFactorial.eval..hs,-q1uIr%F)rrrrVrrXrUrrWNegativeInfinityr isinstancergenslenrrr[rArsrqrYrurErrrs ` r#rczRisingFactorial.eval5s AJJ AJJ ::ae5L !%ZZQ<<  \, Jy+ Ju =(JAJ z)a0008.#$#55#$:-%a.. <#$6D"4yy1}}&02K'L'L!L(./=/=/=/=.3CFFmmQ(@(@!@$**@*@*@*@*/A--$<$<<AJ z)a000 z)%a.. J#$6D"4yy1}}&02K'L'L!L()1@1@1@1@05aSVVq0I0I1*N*N(N!N$%V-6-6-6-6,1!SQ[[1_,E,Eq&J&J$JJ <5 |   v  !     r%Tc ~ddlm}ddlm}|sU|dkdkr1tj|z|d|z z|| |z dzz S|||z||z S||||z||z |dkftj|z|d|z z|| |z dzz dfSNrrrTr,rrr0r.rrr rrrr!rr.s r#rz&RisingFactorial._eval_rewrite_as_gammapsBBBBBBAAAAAA +Q4}a'a!e 4uuaR!VaZ7H7HHH5Q<<%%((* *y U1q5\\EE!HH $a!e , ]A eeAEll *UUA26A:->-> > EGG Gr%c .t||zdz |SNr,)FallingFactorialr rrr!s r#!_eval_rewrite_as_FallingFactorialz1RisingFactorial._eval_rewrite_as_FallingFactorial{sA 1---r%c  ddlm}|jrs|jrn|t||zdz t|dz z |dkftj|zt| zt| |z z dfSdSdSNrrr,Trrrqrrrr rrr!rs r#rz*RisingFactorial._eval_rewrite_as_factorial~sBBBBBB < JAL J91q519%%iA&6&66A>!)QB--/ 1"q&0A0AA4HJJ J J J J Jr%c `|jr&t|t||zdz |zSdSrrqrbinomialrs r#_eval_rewrite_as_binomialz)RisingFactorial._eval_rewrite_as_binomials9 < 9Q<<(1q519a"8"88 8 9 9r%Nc ddlm}|r||tj}|tjur/|||zdd||z S|tjurFtj|z|d|z z|| |z dzddz S||ddSNrr tractableT)deepr,)r0r.rrrWrewriterrr rrlimitvarr!r.k_lims r#_eval_rewrite_as_tractablez*RisingFactorial._eval_rewrite_as_tractablesAAAAAA  kFF8QZ00E ""a!e ,,[t,DDuuQxxOP!,,, q(q1u5qb1fqj8I8I8Q8QR]dh8Q8i8iij||E""**;T*BBBr%ct|jdj|jdj|jdjfSNrr,r r1rqrrrs r#rz RisingFactorial._eval_is_integer;$)A,149Q<3J)A,5788 8r%rr) r&r'r(r)rrcrrrrrrr*r%r#rrs;;z88[8t G G G G...JJJ999CCCC88888r%rcPeZdZdZedZd dZdZdZdZ d d Z d Z dS) ra0 Falling factorial (related to rising factorial) is a double valued function arising in concrete mathematics, hypergeometric functions and series expansions. It is defined by .. math:: \texttt{ff(x, k)} = (x)_k = x \cdot (x-1) \cdots (x-k+1) where `x` can be arbitrary expression and `k` is an integer. For more information check "Concrete mathematics" by Graham, pp. 66 or [1]_. When `x` is a `~.Poly` instance of degree $\ge 1$ with single variable, `(x)_k = x(y) \cdot x(y-1) \cdots x(y-k+1)`, where `y` is the variable of `x`. This is as described in >>> from sympy import ff, Poly, Symbol >>> from sympy.abc import x >>> n = Symbol('n', integer=True) >>> ff(x, 0) 1 >>> ff(5, 5) 120 >>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4) True >>> ff(Poly(x**2, x), 2) Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ') >>> ff(n, n) factorial(n) Rewriting is complicated unless the relationship between the arguments is known, but falling factorial can be rewritten in terms of gamma, factorial and binomial and rising factorial. >>> from sympy import factorial, rf, gamma, binomial, Symbol >>> n = Symbol('n', integer=True, positive=True) >>> F = ff(n, n - 2) >>> for i in (rf, ff, factorial, binomial, gamma): ... F.rewrite(i) ... RisingFactorial(3, n - 2) FallingFactorial(n, n - 2) factorial(n)/2 binomial(n, n - 2)*factorial(n - 2) gamma(n + 1)/2 See Also ======== factorial, factorial2, RisingFactorial References ========== .. [1] https://mathworld.wolfram.com/FallingFactorial.html .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268, 1995. c tt|}tjus|tjur tjS|jr|krt S|jr|jr tjS|jrtj ur tj Stj ur|j r tj Stj SttrWj}t|dkrt!dt#fdt%t'|dSt#fdt%t'|dStj ur tj Stj ur tj Sttrkj}t|dkrt!ddt#fdt%dt)t'|dzdz Sdt#fdt%dt)t'|dzdz SdS)Nr,z0ff only defined for polynomials on one generatorc6|| zSrrrs r#rz'FallingFactorial.eval..s./!or%c||z zSrr*rs r#rz'FallingFactorial.eval..rr%rc4||zSrrrs r#rz'FallingFactorial.eval..s011771::r%c||zzSrr*rs r#rz'FallingFactorial.eval.. sAEr%)rrrrqrrXrUrVrrWrrrrrrrrr[rArsrs ` r#rczFallingFactorial.evals AJJ AJJ ::ae5L \, Ja1ffQ<<  \* Jy) Ju =&JAJ z)a0008.#$#55#$:-%a.. <#$6D"4yy1}}&02K'L'L!L(./>/>/>/>.3CFFmmQ(@(@!@$**@*@*@*@*/A--$<$<<AJ z)a000 z)%a.. J#$6D"4yy1}}&02K'L'L!L()1?1?1?1?05aSVVq0I0I1*N*N(N!N$%V,B,B,B,B,1!SQ[[1_,E,Eq&J&J$JJS* J* Jr%Tc ~ddlm}ddlm}|sU|dkdkr+tj|z|||z z|| z S||dz|||z dzz S|||dz|||z dzz |dkftj|z|||z z|| z dfSrrrs r#rz'FallingFactorial._eval_rewrite_as_gamma sBBBBBBAAAAAA 3A$}a'a!e 4uuaRyy@@5Q<<%%A "2"22 2y U1q5\\EE!a%!),, ,a1f 5 ]A eeAEll *UUA2YY 6 =?? ?r%c .t||z dz|Sr)rfrs r# _eval_rewrite_as_RisingFactorialz1FallingFactorial._eval_rewrite_as_RisingFactorials!a%!)Qr%c T|jr t|t||zSdSrrrs r#rz*FallingFactorial._eval_rewrite_as_binomials/ < 1Q<<(1a..0 0 1 1r%c  ddlm}|jrs|jrn|t|t| |zz |dkftj|zt||z dz zt| dz z dfSdSdSrrrs r#rz+FallingFactorial._eval_rewrite_as_factorialsBBBBBB < QAL Q91iQ///a8!)AEAI"6"66y!a7H7HH$OQQ Q Q Q Q Qr%Nc ddlm}|r||tj}|tjur@tj|z|||z ddz|| z S|tjur5||dz|||z dzddz S||ddSr)r0r.rrrWrrrrs r#rz+FallingFactorial._eval_rewrite_as_tractable%sAAAAAA  YFF8QZ00E "" q(q1u)=)=kPT)=)U)UUX]X]_`^`XaXaab!,,,a!e uuQUQY'7'7'?'? RV'?'W'WWX||E""**;T*BBBr%ct|jdj|jdj|jdjfSrr rs r#rz!FallingFactorial._eval_is_integer/r r%rr) r&r'r(r)rrcrrrrrrr*r%r#rrs<<|2J2J[2Jh ? ? ? ?   111QQQCCCC88888r%rceZdZdZddZedZedZdZdZ dZ dd Z dd Z d Z dZdZddZd S)ra Implementation of the binomial coefficient. It can be defined in two ways depending on its desired interpretation: .. math:: \binom{n}{k} = \frac{n!}{k!(n-k)!}\ \text{or}\ \binom{n}{k} = \frac{(n)_k}{k!} First, in a strict combinatorial sense it defines the number of ways we can choose `k` elements from a set of `n` elements. In this case both arguments are nonnegative integers and binomial is computed using an efficient algorithm based on prime factorization. The other definition is generalization for arbitrary `n`, however `k` must also be nonnegative. This case is very useful when evaluating summations. For the sake of convenience, for negative integer `k` this function will return zero no matter the other argument. To expand the binomial when `n` is a symbol, use either ``expand_func()`` or ``expand(func=True)``. The former will keep the polynomial in factored form while the latter will expand the polynomial itself. See examples for details. Examples ======== >>> from sympy import Symbol, Rational, binomial, expand_func >>> n = Symbol('n', integer=True, positive=True) >>> binomial(15, 8) 6435 >>> binomial(n, -1) 0 Rows of Pascal's triangle can be generated with the binomial function: >>> for N in range(8): ... print([binomial(N, i) for i in range(N + 1)]) ... [1] [1, 1] [1, 2, 1] [1, 3, 3, 1] [1, 4, 6, 4, 1] [1, 5, 10, 10, 5, 1] [1, 6, 15, 20, 15, 6, 1] [1, 7, 21, 35, 35, 21, 7, 1] As can a given diagonal, e.g. the 4th diagonal: >>> N = -4 >>> [binomial(N, i) for i in range(1 - N)] [1, -4, 10, -20, 35] >>> binomial(Rational(5, 4), 3) -5/128 >>> binomial(Rational(-5, 4), 3) -195/128 >>> binomial(n, 3) binomial(n, 3) >>> binomial(n, 3).expand(func=True) n**3/6 - n**2/2 + n/3 >>> expand_func(binomial(n, 3)) n*(n - 2)*(n - 1)/6 In many cases, we can also compute binomial coefficients modulo a prime p quickly using Lucas' Theorem [2]_, though we need to include `evaluate=False` to postpone evaluation: >>> from sympy import Mod >>> Mod(binomial(156675, 4433, evaluate=False), 10**5 + 3) 28625 Using a generalisation of Lucas's Theorem given by Granville [3]_, we can extend this to arbitrary n: >>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2) 3744312326 References ========== .. [1] https://www.johndcook.com/blog/binomial_coefficients/ .. [2] https://en.wikipedia.org/wiki/Lucas%27s_theorem .. [3] Binomial coefficients modulo prime powers, Andrew Granville, Available: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf r,c:ddlm}|dkr=|j\}}t|||d|dz|d||z dzz zS|dkr=|j\}}t|||d||z dz|d|dzz zSt ||)Nr)r/r,r?)r0r/r1rr )r r2r/rFrs r#r3zbinomial.fdiffsEEEEEE q==9DAqAq>>99QA#6#6 !QUQY''$() ) ]]9DAqAq>>99QA #:#: !QU##$$% %%T844 4r%c|jr|jr|dkrt|t|}}||kr tjS||dzkr||z }t"t t j||S||z d}}td|dzD]}|dz }||z|z}t |S||z d}}td|dzD] }|dz }||z} |t|z SdS)Nrr?r,) rXrArrur\rbincoefr[ _factorial)r rFrryr`ras r#rzbinomial._evals  < .| .Q1vvs1vv1q556MaZZAA $"5=A#6#6777E16q!a%--AFA#aZ1_FFv&E16q!a%  AFAaKFF 1 --3 . .r%c0tt||f\}}||z }|j|j}}|js |s|dur|jr t jS|dz js|s|dur |dz jr|S|jrW|js |r|r|jr t jS|j r0| ||}|r| dn|SdS|dur|r t j S|j r5ddl m}||dz||dz|||z dzzz SdS)NFr,T)basicrr)rwrrrrqrUrrVrYru is_numberrexpandrZr0r.)rErFrryn_nonnegn_isintrgr.s r#rcz binomial.evals7QF##1 E,al' 9 ( g&6&6I'75L E?  Gu,<,<UO-=H < @} > >g >!- >v  >ii1oo14=szzz---#= > >  7 $ $ [ @ E E E E E E5Q<<q1ueeAEAI.>.>!>? ? @ @r%cd|j\}}td|||fDrtdtd|||fDr]t t ||f\}}t |d}}|dkr tjS|dkr| |zdz }|dzrdnd}||kr tjS|j }t |}|r||kr4||}}|s|r*|t||z||zz|z}||z||z}}|(|*n||z } || kr| |} }d} td|dzD] } | | z|z} | } t|dz| dzD] } | | z|z} || z}t| dz|dzD] } || z|z} |t| | z|z|dz |z}||z}nt||kr|dkrt|||}nt t|} tjd|dzD]}|||z kr ||z|z}||dzkr|| kr||z||zkr||z|z}9||}}dx}}|dkr1t ||z||z|zk}||z||z}}||z }|dk1|dkr|t|||z}||z}t||zSdS)Nc3(K|] }|jduVdS)FN)rq.0rs r# z%binomial._eval_Mod..s)88q|u$888888r%z"Integers expected for binomial Modc3$K|] }|jV dSr)rXr&s r#r(z%binomial._eval_Mod..s$//q|//////r%r,rr?ro)r1anyrallrwrArsrrurvrr[rerBrrrC)r rKrFrrxrgrzrGKrykfradfMrIras r#r|zbinomial._eval_Modsy1 88q!Qi888 8 8 CABB B //aAY/// / /K sQF##DAq!ffaB1uuv 1uuBFQJaC&bbQ1uuv kGRB8 &66aqA0q0!(1r61r6":"::R? BwR10q0 AA1uu !1B"1a!e__''TBYB"1q5!a%00''TBY2IC"1q5!a%00))!!ebj3r"urz262666C2ICCqA!q&&"1a++aMM"-aQ77&&Eq1u}}!%i"na u9q5y00"%e)b.C !1"# a!ee #QY1u9q=$A B BA#$:qEzqA1HC !ee 773uc2#6#66C2ICS1W:: WK K r%c x|jd}|jrt|jS|jd}||z jr||z }|jrh|jr t jS|jr t jS|jdd}}td|dzD] }|||z |zz}|t|z St|jS)z Function to expand binomial(n, k) when m is positive integer Also, n is self.args[0] and k is self.args[1] while using binomial(n, k) rr,) r1rTrrXrUrrVrYrur[r)r hintsrFrr`ras r#_eval_expand_funczbinomial._eval_expand_func3s IaL ; (TY' ' IaL aC  AA < (y .u  .v  IaL!6q!a%((Aa!eai'FF 1 --TY' 'r%c ft|t|t||z zz Sr)rr rFrr!s r#rz#binomial._eval_rewrite_as_factorialNs*||Yq\\)AE*:*::;;r%Tc lddlm}||dz||dz|||z dzzz Sr~r)r rFrrr!r.s r#rzbinomial._eval_rewrite_as_gammaQsNAAAAAAuQU||UU1q5\\%%A *:*::;;r%Nc T|||dS)Nr)rr)r rFrrr!s r#rz#binomial._eval_rewrite_as_tractableUs&**1a0088EEEr%c T|jr t||t|z SdSr)rqffrr5s r#rz*binomial._eval_rewrite_as_FallingFactorialXs/ < +a88ill* * + +r%cP|j\}}|jr |jrdS|jdurdSdSNTF)r1rqr rFrs r#rzbinomial._eval_is_integer\s?y1 < AL 4 \U " "5# "r%c|j\}}|jr)|jr$|js|js|jrdS|jdurdSdSdSdSr;)r1rqrrrYrr<s r#rzbinomial._eval_is_nonnegativecspy1 < AL  1= AI te##     $#r%rcdddlm}|||||S)Nrr)rr)r0r.rr)r rrrr.s r#rzbinomial._eval_as_leading_termks;AAAAAA||E""88D8QQQr%rrrr)r&r'r(r)r3rrrcr|r3rrrrrrrr*r%r#rr<s[[z 5 5 5 5..[.<@@[@.QQQf(((6<<<<<<<FFFF+++RRRRRRr%rN)/ __future__r functoolsr sympy.corerrrrsympy.core.cacher sympy.core.functionr r r sympy.core.logicr sympy.core.numbersrrrsympy.core.relationalrsympy.external.gmpyrr\ sympy.ntheoryrsympy.ntheory.residue_ntheoryrsympy.polys.polytoolsrmathrrrrrBrrrrrrrr9rr*r%r#rLs""""""------------$$$$$$GGGGGGGGGG&&&&&&----------$$$$$$------666666&&&&&&==========     H   &s>s>s>s>s>%s>s>s>j     *   _____(___Dp0p0p0p0p0&p0p0p0p^8^8^8^8^8+^8^8^8BY8Y8Y8Y8Y8,Y8Y8Y8xqRqRqRqRqR$qRqRqRqRqRr%