sg|ddlmZddlmZddlmZmZmZmZddl 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.y)) annotations)reduce)SsympifyDummyMod)cacheit)FunctionArgumentIndexError PoleError) fuzzy_and)IntegerpiI)Eq)gmpy)sieve) binomial_mod)Poly) factorialprodsqrtceZdZdZdZy)CombinatorialFunctionz(Base class for combinatorial functions. c ^ddlm}||}|d}|||d||zkr|S|S)Nr)combsimpmeasureratio)sympy.simplify.combsimpr)selfkwargsrexprrs [/var/www/html/venv/lib/python3.12/site-packages/sympy/functions/combinatorial/factorials.py_eval_simplifyz$CombinatorialFunction._eval_simplifys=4~# 4=F7OGDM9 9K N)__name__ __module__ __qualname____doc__r$r%r#rrs 2r%rceZdZUdZddZgdZgZded<edZ edZ edZ d Z d Z dd Zd Zd ZdZdZdZdZddZy)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}|dk(r2||jddz|d|jddzzSt ||)Nr)gamma polygamma)'sympy.functions.special.gamma_functionsr-r.argsr )r argindexr-r.s r#fdiffzfactorial.fdiffUsJN q=1)*9Q ! q8H+II I$T84 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]8}d|}} ||z}|dkDr|dzdk(r||z}nn|dkDs(|j |:tj|dz|dzdzD]}||zdzdk(s|j |!t tj|dzdz|dz}t |}||zS)N!r4r/r) _small_swingint_sqrtr primerangeappendr) clsnNprimesprimepq L_product R_products r#_swingzfactorial._swingds r6##A& &E!H rvA))!QU3 %!1%KA1uq5A:JAq5MM!$ %))!a%A: )J!#q(MM%( )U--adQhA>?IV IY& &r%c`|dkry|j|dzdz|j|zS)Nr?r/) _recursiverN)rErFs r#rPzfactorial._recursives1 q5NN1a4(!+SZZ]: :r%ct|}|jr9|jrtjS|tj urtj S|j r|jrtjS|j}|dkr\|js3d}tddD]"}||z}|jj|$|j|dz }t%|St tj|}t%|St|j!d}|j#|d||z zz}t%|Syy)Nr/1r?)r is_Numberis_zerorOneInfinity is_Integer is_negativeComplexInfinityrJr<rangerD_gmpyfacbincountrPr)rErFresultibitss r#evalzfactorial.evals) AJ ;;yyuu ajjzz!==,,,A2v"44%&F%*1b\E &!  # 5 5 < , !3t<==r%r/TNr)r&r'r(r)r3r@r<__annotations__ classmethodrNrPrcrmr|rrrrrrrrr*r%r#rr$s.`5L $&y%''<;; &+&+P<"<) * *  >r%rc eZdZy)MultiFactorialN)r&r'r(r*r%r#rrsr%rcfeZdZdZeedZedZdZdZ dZ d dZ dZ d Z d Zy ) 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|stjS|dk(rtjSd\}}td|dzD]}||dz ||zz}}|S)Nr/)r/rr?)rrVrur[)r rFz1z2ras r#_evalzsubfactorial._evalGs]55L !V66MFB1a!e_ /a!eb2g.B /Ir%c|jrn|jr|jr|j|S|tj urtj S|tj urtj SyyN)rTrXrrrrNaNrW)rErs r#rczsubfactorial.evalTsZ ==~~#"4"4yy~%uu  "zz!# r%cl|jdjr|jdjryyyr)r1is_oddrrrs r#rzsubfactorial._eval_is_even^s. 99Q<  499Q<#>#>$? r%cl|jdjr|jdjryyyrrrs 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_factorialfsA7 #J MM1 y| +~ !aC[ 999r%c 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\>O a(aRU3Y7 37B8OOa.!"%b'* *r%c Hddlm}||dzdtjz S)Nr) uppergammar/ro)r0rrExp1)r rr!rs r#_eval_rewrite_as_uppergammaz(subfactorial._eval_rewrite_as_uppergammarsF#'2&qvv--r%cl|jdjr|jdjryyyrrrs r#_eval_is_nonnegativez!subfactorial._eval_is_nonnegativevrr%cl|jdjr|jdjryyyr)r1is_evenrrrs r# _eval_is_oddzsubfactorial._eval_is_oddzs/ 99Q<  DIIaL$?$?%@ r%Nr)r&r'r(r)rr rrcrrrrrrrr*r%r#rrs['R    "": * .r%rc@eZdZdZedZdZdZdZdZ d dZ y) 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 cZ|jr|js td|jr<|jr|dz }d|zt |zSt |t |dz z S|jr)|tjd|z dz zzt | z Stdy)Nz> ">?? !!;;aAa4)A,.. ~ 37(;;;zzAMMa#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|tjurtjStjur t |S|j r|j rtjS|jrىtjurtjStjur,|jrtjStjSttrGj}t|dk7r tdt!fdt#t%|dSt!fdt#t%|dStjurtjStjurtjSttrWj}t|dk7r tddt!fdt#dt't%|dzdz Sdt!fdt#dt't%|dzdz S|j(dk(r*j(rj*rtj,Syyy)Nr/0rf only defined for polynomials on one generatorc,|j|zSrshiftrrars r#z&RisingFactorial.eval..Qs./nr%c||zzSrr*rs r#rz&RisingFactorial.eval..Uq!a%yr%c.|j| zSrrrs r#rz&RisingFactorial.eval..ds01177A2;r%c||z zSrr*rs r#rz&RisingFactorial.eval..hs,-q1uIr%F)rrrrVrrXrUrrWNegativeInfinityr isinstancergenslenrrr[rArsrqrYrurErrrs ` r#rczRisingFactorial.eval5s AJ AJ :aee55L !%%ZQ<  \\yyuu ==AJJ zz)a00088#$#5#55#$::-%a.#$66D"4y1}&02K'L!L(./=.3CFmQ(@!@$**@*/A-$<<AJJ zz)a000 zz)%a.#$66D"4y1}&02K'L!L()1@05aSVq0I1*N(N!N$%V-6,1!SQ[1_,Eq&J$JJ <<5 || vv !.| !r%c Rddlm}ddlm}|sK|dkdk(r/tj |z|d|z z|| |z dzz S|||z||z S||||z||z |dkDftj |z|d|z z|| |z dzz dfSNrrrTr/rrr0r-rrr rrrr!rr-s r#rz&RisingFactorial._eval_rewrite_as_gammapsBAQ4}}a'a!e 4uaR!VaZ7HHHQ<%(* * 1q5\E!H $a!e , ]]A eAEl *UA26A:-> > EG Gr%c &t||zdz |SNr/)FallingFactorialr rrr!s r#!_eval_rewrite_as_FallingFactorialz1RisingFactorial._eval_rewrite_as_FallingFactorial{sA 1--r%c ddlm}|jri|jr\|t||zdz t|dz z |dkDftj |zt| zt| |z z dfSyyNrrr/Trrrqrrrr rrr!rs r#rz*RisingFactorial._eval_rewrite_as_factorial~s{B <!)QB-/ 1"q&0AA4HJ J);z88t G.J9C8r%rcHeZdZdZedZd dZdZdZdZ d dZ d Z y) 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|tjurtjS|jr|k(r t S|j r|j rtjS|jrىtjurtjStjur,|jrtjStjSttrGj}t|dk7r t!dt#fdt%t'|dSt#fdt%t'|dStjurtjStjurtjSttrWj}t|dk7r t!ddt#fdt%dt)t'|dzdz Sdt#fdt%dt)t'|dzdz Sy)Nr/z0ff only defined for polynomials on one generatorc.|j| zSrrrs r#rz'FallingFactorial.eval..s./!or%c||z zSrr*rs r#rz'FallingFactorial.eval..rr%rc,|j|zSrrrs r#rz'FallingFactorial.eval..s011771:r%c||zzSrr*rs r#rz'FallingFactorial.eval.. sAEr%)rrrrqrrXrUrVrrWrrrrrrrrr[rArsrs ` r#rczFallingFactorial.evals AJ AJ :aee55L \\a1fQ<  \\yyuu ==AJJ zz)a00088#$#5#55#$::-%a.#$66D"4y1}&02K'L!L(./>.3CFmQ(@!@$**@*/A-$<<AJJ zz)a000 zz)%a.#$66D"4y1}&02K'L!L()1?05aSVq0I1*N(N!N$%V,B,1!SQ[1_,Eq&J$JJSr%c Rddlm}ddlm}|sK|dkdk(r)tj |z|||z z|| z S||dz|||z dzz S|||dz|||z dzz |dk\ftj |z|||z z|| z dfSrrrs r#rz'FallingFactorial._eval_rewrite_as_gamma sBAA$}}a'a!e 4uaRy@@Q<%A "22 2 1q5\E!a%!), ,a1f 5 ]]A eAEl *UA2Y 6 =? ?r%c &t||z dz|Sr)rfrs r# _eval_rewrite_as_RisingFactorialz1FallingFactorial._eval_rewrite_as_RisingFactorials!a%!)Qr%c L|jrt|t||zSyrrrs r#rz*FallingFactorial._eval_rewrite_as_binomials# <<Q<(1a.0 0 r%c ddlm}|jri|jr\|t|t| |zz |dk\ftj |zt||z dz zt| dz z dfSyyrrrs r#rz+FallingFactorial._eval_rewrite_as_factorials{B <>> 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 cddlm}|dk(r8|j\}}t|||d|dz|d||z dzz zS|dk(r8|j\}}t|||d||z dz|d|dzz zSt ||)Nr)r.r/r?)r0r.r1rr )r r2r.rFrs r#r3zbinomial.fdiffsE q=99DAqAq>9QA#6!QUQY'$() ) ]99DAqAq>9QA #:!QU#$$% %%T84 4r%c|jr|jr|dk\rt|t|}}||kDrtjS||dzkDr||z }tt t j ||S||z d}}td|dzD]}|dz }||z|z}t |S||z d}}td|dzD] }|dz }||z}|t|z Sy)Nrr?r/) rXrArrur\rbincoefr[ _factorial)r rFrryr`ras r#rzbinomial._evals <<||Q1vs1v1q566MaZAA $"5==A#677E16q!a%-AFA#aZ1_F-v&E16q!a% AFAaKF  1 --3 r%ctt||f\}}||z }|j|j}}|js|s|dur|jrt j S|dz js|s|dur|dz jr|S|jra|js|r|r|jrt jS|jr(|j||}|r|jdS|Sy|dur|rt jS|jr,ddl m}||dz||dz|||z dzzz Sy)NFr/T)basicrr)rwrrrrqrUrrVrYru is_numberrexpandrZr0r-)rErFrryn_nonnegn_isintrgr-s r#rcz binomial.evals7QF#1 E,,all' 99(g&6II55L E??Gu,<UOOH <<}}g!--vv ii1o14szzz-=#= 7$$ $ [[ EQ<q1ueAEAI.>!>? ?r%c|j\}}td|||fDr tdtd|||fDr-t t ||f\}}t |d}}|dkrtjS|dkr| |zdz }|dzrdnd}||kDrtjS|j}t |}|r||kr3||}}|s|r|t||z||zz|z}||z||z}}|r%|r(nk||z } || kDr| |} }d} td|dzD] } | | z|z} | } t|dz| dzD] } | | z|z} || z}t| dz|dzD] } || z|z} |t| | z|z|dz |z}||z}nt||kr|dk7rt|||}nt t|} tj d|dzD]}|||z kDr ||z|z}||dzkDr|| kDr||z||zks.||z|z}7||}}dx}}|dkDr,t ||z||z|zk}||z||z}}||z }|dkDr,|dkDsv|t|||z}||z}t||zSy)Nc38K|]}|jduyw)FN)rq.0rs r# z%binomial._eval_Mod..s8q||u$8sz"Integers expected for binomial Modc34K|]}|jywr)rXr&s r#r(z%binomial._eval_Mod..s/q||/sr/rr?ro)r1anyrallrwrArsrrurvrr[rerBrrrC)r rKrFrrxrgrzrGKrykfradfMrIras r#r|zbinomial._eval_Mods yy1 8q!Qi8 8AB B /aAY/ /sQF#DAq!faB1uvv 1uBFQJaCbQ1uvv kkGRB6aqAq!(1r61r6"::R? BwR1q AA1u !1B"1a!e_'TBY'B"1q5!a%0'TBY'2IC"1q5!a%0)!!ebj)3r"urz26266C2ICqA!q&"1a+aM"--aQ7&Eq1u}!%i"na u9q5y0"%e)b.C !1"# a!e #QY1u9q=$A BA#$:qEzqA1HC !e 73uc2#66C2IC'&*S1W: W 0r%c |jd}|jrt|jS|jd}||z jr||z }|jrv|jrt j S|jrt 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 IIaL ;;TYY' ' IIaL aC  AA <<yyuu vv  IIaL!6q!a%(Aa!eai'F( 1 --TYY' 'r%c Nt|t|t||z zz Sr)rr rFrr!s r#rz#binomial._eval_rewrite_as_factorialNs#|Yq\)AE*::;;r%c Zddlm}||dz||dz|||z dzzz Sr~r)r rFrrr!r-s r#rzbinomial._eval_rewrite_as_gammaQs2AQU|U1q5\%A *::;;r%Nc D|j||jdS)Nr)rr)r rFrrr!s r#rz#binomial._eval_rewrite_as_tractableUs **1a088EEr%c L|jrt||t|z Syr)rqffrr5s r#rz*binomial._eval_rewrite_as_FallingFactorialXs# <<a8il* * r%cr|j\}}|jr |jry|jduryyNTF)r1rqr rFrs r#rzbinomial._eval_is_integer\s3yy1 <rLs"--$GG&--$-6&== H &s>%s>j * _(_Dp0&p0p^8+^8BY8,Y8xqR$qRr%