\h|SSKJr SSKJr SSKJrJrJrJr SSK J r SSK J r J r Jr SSKJr SSKJrJrJr SSKJr SS KJr SS KJr SS KJr SS KJr SS K J!r"J#r#J$r% "SS\ 5r&"SS\&5r!"SS\&5r'"SS\&5r("SS\&5r)"SS\&5r*"SS\&5r+\*r,\+r-"SS\&5r.g)) annotations)reduce)SsympifyDummyMod)cacheit)DefinedFunctionArgumentIndexError PoleError) fuzzy_and)IntegerpiI)Eq)gmpy)sieve) binomial_mod)Poly) factorialprodsqrtc\rSrSrSrSrSrg)CombinatorialFunctionz(Base class for combinatorial functions. c `SSKJn U"U5nUSnU"U5USU"U5-::aU$U$)Nr)combsimpmeasureratio)sympy.simplify.combsimpr)selfkwargsrexprrs `/var/www/auris/envauris/lib/python3.13/site-packages/sympy/functions/combinatorial/factorials.py_eval_simplify$CombinatorialFunction._eval_simplifys=4~# 4=F7OGDM9 9K N)__name__ __module__ __qualname____firstlineno____doc__r%__static_attributes__r(r'r$rrs 2r'rc\rSrSr%SrSSjr/SQr/rS\S'\ S5r \ S5r \ S 5r S r S rSS jrS rSrSrSrSrSrSrSrg)r$aImplementation 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 cSSKJnJn US:Xa2U"URSS-5U"SURSS-5-$[ X5e)Nr)gamma polygamma)'sympy.functions.special.gamma_functionsr2r3argsr )r!argindexr2r3s r$fdifffactorial.fdiffUsHN q=1)*9Q ! q8H+II I$T4 4r')!r4r4r4r:#r=i;?ii i#r@iSi{/i!imiisXiUiP ioikiIi/LiSi}#rAz list[int]_small_factorialscUS:aURU$[[U55/p2[R"SUS-5H;nSUpeXd-nUS:aUS-S:XaXT-nOOMUS:dM*UR U5 M= [R"US-US-S-5H!nX-S-S:XdMUR U5 M# [ [R"US-S-US-55n[ U5nXx-$)N!r:r4r) _small_swingint_sqrtr primerangeappendr) clsnNprimesprimepq L_product R_products r$_swingfactorial._swingds r6##A& &E!H rv))!QU3!1KA1uq5A:JAq5MM!$4))!a%A:J!#q(MM%(;U--adQhA>?IV I& &r'cbUS:agURUS-5S-URU5-$)NrEr4) _recursiverT)rKrLs r$rWfactorial._recursives1 q5NN1a4(!+SZZ]: :r'c[U5nUR(Ga=UR(a[R$U[R La[R $UR (aUR(a[R$URnUS:aXUR(d4Sn[SS5H"nX#-nURRU5 M$ URUS- nOQ[b[R"U5nO3[U5R!S5nUR#U5SX- --n[%U5$gg)Nr41rE)r is_Numberis_zerorOneInfinity is_Integer is_negativeComplexInfinityrPrBrangerJ_gmpyfacbincountrWr)rKrLresultibitss r$evalfactorial.evals AJ ;;;yyuu ajjzz!==,,,A2v"44%&F%*1b\ &  # 5 5 < US- U:a5URUS- U5n[XcS- U5nUS-(aU*nXa-$URX#5nXa-$ggggg)Nrr4FrE) r6 is_integeris_nonnegativeabsis_nonpositiverZerois_primer`maprGrvrn)r!rQrLaqdisprimefcs r$ _eval_Modfactorial._eval_Mods" IIaL <<, !3t<==r'r(Nr4T)r)r*r+r,r-r8rFrB__annotations__ classmethodrTrWrkrvrrrrrrrrrr.r(r'r$rr$s.`5L $&y%''<;; &+&+P<"<) * *  >r'rc\rSrSrSrg)MultiFactorialir(N)r)r*r+r,r.r(r'r$rrsr'rcp\rSrSrSr\\S55r\S5rSr Sr Sr SSjr S r S rS rS rg ) subfactorialia<The 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 cU(d[R$US:Xa[R$Sup#[SUS-5H nX4S- X2--p2M U$)Nr4)r4rrE)rr^rrc)r!rLz1z2ris r$_evalsubfactorial._evalGsP55L !V66MFB1a!e_!ebg.B%Ir'cUR(azUR(a"UR(aURU5$U[R La[R $U[R La[R $ggN)r\r`r|rrNaNr_)rKrs r$rksubfactorial.evalTsZ ==~~#"4"4yy~%uu  "zz!# r'cURSR(a URSR(agggr)r6is_oddr|rs r$rsubfactorial._eval_is_even^s. 99Q<  499Q<#>#>$? r'cURSR(a URSR(agggrrrs r$rsubfactorial._eval_is_integerbrr'c SSKJn [S5n[RU-[ U5- n[ U5U"XTSU45-$)Nr) summationri)sympy.concrete.summationsrrr NegativeOner)r!rr"rrifs r$_eval_rewrite_as_factorial'subfactorial._eval_rewrite_as_factorialfs?7 #J MM1 y| +~ !C[ 999r'c SSKJn SSKJnJn [ R US--U"[*[-U-5-U"US-S5-U"US-5-U"S5-$)Nr)exp)r2 lowergammar4ry) &sympy.functions.elementary.exponentialrr5r2rrrrr)r!rrr"rr2rs r$r#subfactorial._eval_rewrite_as_gammals\>O a(aRU3Y7 37B8OOa.!"%b'* *r'c HSSKJn U"US-S5[R- $)Nr) uppergammar4ry)r5rrExp1)r!rr"rs r$_eval_rewrite_as_uppergamma(subfactorial._eval_rewrite_as_uppergammarsF#'2&qvv--r'cURSR(a URSR(agggrrrs r$_eval_is_nonnegative!subfactorial._eval_is_nonnegativevrr'cURSR(a URSR(agggr)r6is_evenr|rs r$ _eval_is_oddsubfactorial._eval_is_oddzs/ 99Q<  DIIaL$?$?%@ r'r(Nr)r)r*r+r,r-rr rrkrrrrrrrr.r(r'r$rrs['R    "": * .r'rcJ\rSrSrSr\S5rSrSrSr Sr S Sjr S r g ) factorial2iaThe 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 cUR(aUR(d [S5eUR(aAUR(aUS- nSU-[ U5-$[ U5[ US- 5- $UR(a)U[RSU- S- --[ U*5- $[S5eg)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 ^[T5m[U5nT[RLdU[RLa[R$T[RLa [ U5$UR (GaUR (a[R$UR(aT[RLa[R$T[RLa1UR(a[R$[R$[T[5(aITRn[U5S:wa [S5e[!U4Sj[#[%U55S5$[!U4Sj[#[%U55S5$T[RLa[R$T[RLa[R$[T[5(aYTRn[U5S:wa [S5eS[!U4Sj[#S['[%U55S-5S5- $S[!U4Sj[#S['[%U55S-5S5- $UR(S:Xa4TR((a"TR*(a[R,$ggg)Nr40rf only defined for polynomials on one generatorc,>UTRU5-$rshiftrrirs r$&RisingFactorial.eval..Qs./nr'c>UTU--$rr(rs r$rrU q!a%yr'c.>UTRU*5-$rrrs r$rrds01177A2;r'c>UTU- -$rr(rs r$rrhs,-q1uIr'F)rrrr^rr`r]rr_NegativeInfinityr isinstancergenslenrrrcrGr}r{rarrKrrr s ` r$rkRisingFactorial.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 ZSSKJn SSKJn U(dKUS:*S:Xa/[R U-U"SU- 5-U"U*U- S-5- $U"X-5U"U5- $U"U"X-5U"U5- US:4[R U-U"SU- 5-U"U*U- S-5- S45$NrrrTr4rrr5r2rrr!rrrr"rr2s r$r&RisingFactorial._eval_rewrite_as_gammapsBAQ4}}a'a!e 4uaR!VaZ7HHH<%(* * 15\E!H $a!e , ]]A eAEl *UA26A:-> > EG Gr'c $[X-S- U5$Nr4)FallingFactorialr!rrr"s r$!_eval_rewrite_as_FallingFactorial1RisingFactorial._eval_rewrite_as_FallingFactorial{s 1--r'c  SSKJn UR(amUR(a[U"[X!-S- 5[US- 5- US:4[R U-[U*5-[U*U- 5- S45$ggNrrr4Trrr{rrrr!rrr"rs r$r*RisingFactorial._eval_rewrite_as_factorial~syB <!)QB-/ 1"q&0AA4HJ J);z88t G.J9C8r'rcT\rSrSrSr\S5rS SjrSrSr Sr S S jr S r S r g)riap 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 ^[T5m[U5nT[RLdU[RLa[R$UR(aTU:Xa [ T5$UR (GaUR (a[R$UR(aT[RLa[R$T[RLa1UR(a[R$[R$[T[5(aITRn[U5S:wa [!S5e[#U4Sj[%['U55S5$[#U4Sj[%['U55S5$T[RLa[R$T[RLa[R$[T[5(aYTRn[U5S:wa [!S5eS[#U4Sj[%S[)['U55S-5S5- $S[#U4Sj[%S[)['U55S-5S5- $g)Nr4z0ff only defined for polynomials on one generatorc.>UTRU*5-$rrrs r$r'FallingFactorial.eval..s./!or'c>UTU- -$rr(rs r$rr7rr'rc,>UTRU5-$rrrs r$rr7s011771:r'c>UTU--$rr(rs r$rr7 s AEr')rrrr{rr`r]r^rr_r rr rr r rrrcrGr}rs ` r$rkFallingFactorial.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 VSSKJn SSKJn U(dJUS:S:Xa([R U-U"X!- 5-U"U*5- $U"US-5U"X- S-5- $U"U"US-5U"X- S-5- US:4[R U-U"X!- 5-U"U*5- S45$rrrs r$r'FallingFactorial._eval_rewrite_as_gamma sBAA$}}a'ae 4uaRy@@Q<% "22 2 1q5\E!%!), ,a1f 5 ]]A eAEl *UA2Y 6 =? ?r'c $[X- S-U5$r)rfrs r$ _eval_rewrite_as_RisingFactorial1FallingFactorial._eval_rewrite_as_RisingFactorials!%!)Qr'c TUR(a[U5[X5-$grr!rs r$r#*FallingFactorial._eval_rewrite_as_binomials! <<Q<(1.0 0 r'c  SSKJn UR(amUR(a[U"[U5[U*U-5- US:4[R U-[X!- S- 5-[U*S- 5- S45$ggrrrs r$r+FallingFactorial._eval_rewrite_as_factorialsyB <>> 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 cSSKJn US:Xa5URup4[X45U"SUS-5U"SX4- S-5- -$US:Xa5URup4[X45U"SX4- S-5U"SUS-5- -$[ X5e)Nr)r3r4rE)r5r3r6r"r )r!r7r3rLrs r$r8binomial.fdiffsE q=99DAA>9QA#6!QUQY'$() ) ]99DAA>9Q #:!QU#$$% %%T4 4r'cUR(aUR(aUS:a[U5[U5p!X!:a[R$X!S-:aX- n[b[ [R "X55$X- SpC[SUS-5HnUS- nXC-U-nM [ U5$X- SpC[SUS-5H nUS- nXC-nM U[U5- $g)NrrEr4) r`rGrrrdrbincoefrc _factorial)r!rLrrrhris r$rbinomial._evals <<||Q1vs1v1566MaZA $"5==#677E16q!a%AFA#Z1_F)v&E16q!a%AFAKF) 1 --3 r'c[[X45upX- nURURpTUR(dU(dUSLa!UR(a[ R $US- R(d U(dUSLaUS- R(aU$UR(a{UR(dU(a(U(a!UR(a[ R$UR(a)URX5nU(aURSS9$U$gUSLaU(a[ R$UR(a+SSK Jn U"US-5U"US-5U"X- S-5-- $g)NFr4T)basicrr)rrr|r{r]rr^rar is_numberrexpandrbr5r2)rKrLrrn_nonnegn_isintrpr2s r$rk binomial.evals7QF# E,,all' 99(g&6II55L E??Gu,<UOOH <<}}g!--vv iio14szzz-=#= 7$$ $ [[ EQ<q1ueAEAI.>!>? ?r'cURup#[SX#U455(a [S5e[SX#U455(GaA[ [ X#45up#[ U5SpTUS:a[R$US:aU*U-S- nUS-(aSOSnX2:a[R$URn[ U5nU(aXB:aAX#pU(dU(a/U[Xt-X-5-U-nXt-X-pU(aM&U(aM/GOiX#- n X9:aXpSn [SUS-5H n X-U-n M U n [US-U S-5H n X-U-n M X\-n[U S-US-5H n X[-U-nM U[X-U-US- U5-nXT-nO[U5U:aUS:wa [X#U5nO[ [U55n [R "SUS-5HnXU- :a X^-U-nMXS-:aMX:aX.-X>-:a X^-U-nM6M8X#pS=nnUS:a)[ X~-X-U-:5nX~-X-pUU- nUS:aM)US:dMuU[XU5-nXT-nM [XQ-5$g)Nc3<# UHoRSLv M g7f)FN)r{.0rs r$ %binomial._eval_Mod..s8i||u$isz"Integers expected for binomial Modc38# UHoRv M g7fr)r`rZs r$r\r]s/Y||Ysr4rrEry)r6anyrallrrGr}rrrr"rcrnrHrrrI)r!rQrLrrrprrMKrkfridfMrOras r$rbinomial._eval_Modsyy 8qQi8 8 8AB B /aAY/ / /sQF#DA!fa1uvv 1uBFQJaCbQuvv kkGRB6qq!(1616"::R? w1!qq Au 1B"1a!e_TBY-B"1q5!a%0TBY1IC"1q5!a%0!ebj13rurz26266CICqA!q&"1+aM"--aQ7E1u}!i"na 9qy0"%)b.C1 !1"# a!e #QY19q=$A BA#$:qzq1HC !e 73u2#66CIC'8*SW: W 0r'c URSnUR(a[UR6$URSnX#- R(aX#- nUR(aUR(a[ R $UR(a[ R$URSSpB[SUS-5H nXBU- U--nM U[U5- $[UR6$)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) rr4) r6r\r"r`r]rr^rarrcrO)r!hintsrLrrhris r$_eval_expand_funcbinomial._eval_expand_func3s IIaL ;;TYY' ' IIaL C  A <<yyuu vv  IIaL!6q!a%A!eai'F) 1 --TYY' 'r'c L[U5[U5[X- 5-- $r)rr!rLrr"s r$r#binomial._eval_rewrite_as_factorialNs!|Yq\)AE*::;;r'c XSSKJn U"US-5U"US-5U"X- S-5-- $rr)r!rLrrr"r2s r$rbinomial._eval_rewrite_as_gammaQs0AQU|U1q5\% *::;;r'Nc BURX5RS5$)Nr')rr))r!rLrr+r"s r$r-#binomial._eval_rewrite_as_tractableUs**1088EEr'c TUR(a[X5[U5- $gr)r{ffrrls r$r*binomial._eval_rewrite_as_FallingFactorialXs! <<a8il* * r'cURupUR(aUR(agURSLaggNTF)r6r{r!rLrs r$rbinomial._eval_is_integer\s1yy <rs"--$NN&--$-6&== O &s>%s>j * _(_Dp0&p0p^8+^8BY8,Y8xqR$qRr'