U 9%e@sDddlmZddlmZddlmZmZmZmZddl m Z ddl m Z m Z mZddlmZddlmZmZmZddlmZdd lmZmZdd lmZdd lmZdd lmZ m!Z!m"Z#Gd dde Z$Gddde$ZGddde$Z%Gddde$Z&Gddde$Z'Gddde$Z(Gddde$Z)e(Z*e)Z+Gddde$Z,dS)) annotations)reduce)SsympifyDummyMod)cacheit)FunctionArgumentIndexError PoleError) fuzzy_and)IntegerpiI)Eq)HAS_GMPYgmpy)sieve)Poly) factorialprodsqrtc@seZdZdZddZdS)CombinatorialFunctionz(Base class for combinatorial functions. cKs<ddlm}||}|d}|||d||kr8|S|S)Nr)combsimpmeasureratio)Zsympy.simplify.combsimpr)selfkwargsrexprrrg/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/functions/combinatorial/factorials.py_eval_simplifys  z$CombinatorialFunction._eval_simplifyN)__name__ __module__ __qualname____doc__r!rrrr rsrc!@seZdZUdZd>ddZdddddddddd d d d d dddddddddddddddddddg!ZgZded <ed!d"Z ed#d$Z ed%d&Z d'd(Z d)d*Z d?d,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd@d>> 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 cCsLddlm}m}|dkr>||jdd|d|jddSt||dS)Nr)gamma polygammar&)'sympy.functions.special.gamma_functionsr'r(argsr )rargindexr'r(rrr fdiffTs&zfactorial.fdiff#i;?ii ii#iSi{/i!imiisXiUiP ioikiIi/LiSi}i#z list[int]_small_factorialsc Cs|dkr|j|Stt|g}}td|dD]J}d|}}||}|dkrl|d@dkrj||9}qBqlqB|dkr4||q4t|d|ddD]}||d@dkr||qtt|dd|d}t|}||SdS)N!r-r&r) _small_swingint_sqrtr primerangeappendr) clsnNZprimesprimepqZ L_productZ R_productrrr _swingcs$      zfactorial._swingcCs,|dkr dS||dd||SdS)Nr5r&) _recursiverA)r;r<rrr rBszfactorial._recursivecCst|}|jr|jrtjS|tjkr*tjS|jr|jryexbsrrr _facmods&  zfactorial._facmodcCs|jd}|jr|jr|jrt|}||}|jr8tjS|j}|dkrl|rRd|S|dkr|djrtjSnv|jr|jrt t |||f\}}}|r|d|kr| |d|}t ||d|}|dr| }n | ||}||SdS)Nrr&Fr5) r* is_integeris_nonnegativeabsZis_nonpositiverZerois_primerImapr7r[rS)rr@r<aqdisprimefcrrr _eval_Mods*   zfactorial._eval_ModTcKsddlm}||dSNrr'r&r)r')rr< piecewiserr'rrr _eval_rewrite_as_gammas z factorial._eval_rewrite_as_gammacKs8ddlm}|jr4|jr4tddd}|||d|fSdS)Nr)ProductrPT)integerr&)Zsympy.concrete.productsrnr_r^r)rr<rrnrPrrr _eval_rewrite_as_Products   z"factorial._eval_rewrite_as_ProductcCs |jdjr|jdjrdSdSNrTr*r^r_rrrr _eval_is_integerszfactorial._eval_is_integercCs |jdjr|jdjrdSdSrqrrrsrrr _eval_is_positiveszfactorial._eval_is_positivecCs$|jd}|jr |jr |djSdS)Nrr5rrrxrrr _eval_is_evens  zfactorial._eval_is_evencCs$|jd}|jr |jr |djSdS)Nrr-rrrvrrr _eval_is_composites  zfactorial._eval_is_compositecCs|jd}|js|jrdSdSrq)r*r_Z is_nonintegerrvrrr _eval_is_reals  zfactorial._eval_is_realNrcCsH|jd|}||d}|jr(tjS|js8||Std|dS)NrzCannot expand %s around 0) r*Zas_leading_termsubsrFrrG is_infinitefuncr )rrwlogxcdirargZarg0rrr _eval_as_leading_terms  zfactorial._eval_as_leading_term)r&)T)Nr)r"r#r$r%r,r6r3__annotations__ classmethodrArBrRr[rhrmrprtrurxryrzrrrrr r#sj 0      rc@s eZdZdS)MultiFactorialN)r"r#r$rrrr rsrc@sfeZdZdZeeddZeddZddZdd Z d d Z dd dZ ddZ ddZ ddZdS) 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 cCsR|s tjS|dkrtjSd\}}td|dD]}||d||}}q.|SdS)Nr&)r&rr5)rrGrarL)rr<Zz1Zz2rPrrr _eval>szsubfactorial._evalcCs@|jr<|jr|jr||S|tjkr,tjS|tjkrddlm}td}tj|t|}t||||d|fS)Nr) summationrP)Zsympy.concrete.summationsrrr NegativeOner)rrrrrPfrrr _eval_rewrite_as_factorial]s z'subfactorial._eval_rewrite_as_factorialTcKs^ddlm}ddlm}m}tj|d|t t|||dd||d|dS)Nr)exp)r' lowergammar&r\) Z&sympy.functions.elementary.exponentialrr)r'rrrrr)rrrlrrr'rrrr rmcs , z#subfactorial._eval_rewrite_as_gammacKs ddlm}||ddtjS)Nr) uppergammar&r\)r)rrZExp1)rrrrrrr _eval_rewrite_as_uppergammais z(subfactorial._eval_rewrite_as_uppergammacCs |jdjr|jdjrdSdSrqrrrsrrr _eval_is_nonnegativemsz!subfactorial._eval_is_nonnegativecCs |jdjr|jdjrdSdSrq)r*is_evenr_rsrrr _eval_is_oddqszsubfactorial._eval_is_oddN)T)r"r#r$r%rrrrRrxrtrrmrrrrrrr rs)   rc@sFeZdZdZeddZddZddZdd Zd d Z dd dZ dS) 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 cCs~|jrz|jstd|jrL|jr8|d}d|t|St|t|dS|jrr|tj d|dt| StddS)Nz>> 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. cstt|}tjks$|tjkr*tjStjkrHsz&RisingFactorial.eval..cs ||Srrrrrr rLcs|| Srrrrrr r[scs ||Srrrrrr r_sF)rrrrGrrIrFrrHNegativeInfinityr isinstancergenslenrrrLr7r`r^rJrar;rwrrrrr rR,s^               zRisingFactorial.evalTcKsddlm}ddlm}|sd|dkdkrPtj||d||| |dS|||||S|||||||dkftj||d||| |ddfSNrrrjTr&rrr)r'rrrrwrrlrrr'rrr rmgs   (*z&RisingFactorial._eval_rewrite_as_gammacKst||d|SNr&)FallingFactorialrrwrrrrr !_eval_rewrite_as_FallingFactorialrsz1RisingFactorial._eval_rewrite_as_FallingFactorialcKshddlm}|jrd|jrd|t||dt|d|dkftj|t| t| |dfSdSNrrr&Trrr^rrrrrwrrrrrr rus   "$z*RisingFactorial._eval_rewrite_as_factorialcKs$|jr t|t||d|SdSrr^rbinomialrrrr _eval_rewrite_as_binomial|sz)RisingFactorial._eval_rewrite_as_binomialNcKsddlm}|r||tj}|tjkrF|||jddd||S|tjkrtj||d||| |djdddS||jdddSNrrj tractableT)deepr&)r)r'r{rrHrewriterrrrwrlimitvarrr'Zk_limrrr _eval_rewrite_as_tractables   2z*RisingFactorial._eval_rewrite_as_tractablecCs&t|jdj|jdj|jdjfSNrr&r r*r^r_rsrrr rts z RisingFactorial._eval_is_integer)T)N) r"r#r$r%rrRrmrrrrrtrrrr rs= :  rc@sPeZdZdZeddZdddZddZd d Zd d Z dddZ ddZ d S)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. cstt|}tjks$|tjkr*tjS|jr@|kr@tS|jr|jrTtjS|jrtj krjtj Stj kr|j rtj Stj Sn`t t r̈j}t|dkrtdqtfddtt|dSntfddtt|dSntj krtj Stj krtj St t rdj}t|dkr8tdn*dtfddtdtt|ddSn*dtfddtdtt|ddSdS) Nr&z0ff only defined for polynomials on one generatorcs|| Srrrrrr rsz'FallingFactorial.eval..cs ||Srrrrrr rrrcs||Srrrrrr rscs ||Srrrrrr rr)rrrr^rrIrFrGrrHrrrrrrrrrLr7r`rrrr rRsX             zFallingFactorial.evalTcKsddlm}ddlm}|sd|dkdkrHtj|||||| S||d|||dS|||d|||d|dkftj|||||| dfSrrrrrr rms    ""z'FallingFactorial._eval_rewrite_as_gammacKst||d|Sr)rfrrrr _eval_rewrite_as_RisingFactorialsz1FallingFactorial._eval_rewrite_as_RisingFactorialcKs|jrt|t||SdSrrrrrr rsz*FallingFactorial._eval_rewrite_as_binomialcKshddlm}|jrd|jrd|t|t| ||dkftj|t||dt| ddfSdSrrrrrr rs   *z+FallingFactorial._eval_rewrite_as_factorialNcKsddlm}|r||tj}|tjkrRtj||||jddd|| S|tjkr||d|||djdddS||jdddSr)r)r'r{rrHrrrrrrr rs  * &z+FallingFactorial._eval_rewrite_as_tractablecCs&t|jdj|jdj|jdjfSrrrsrrr rt&s z!FallingFactorial._eval_is_integer)T)N) r"r#r$r%rrRrmrrrrrtrrrr rs> 4  rc@seZdZdZdddZeddZeddZd d Zd d Z d dZ dddZ d ddZ ddZ ddZddZd!ddZdS)"ra1Implementation 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 References ========== .. [1] https://www.johndcook.com/blog/binomial_coefficients/ r&cCsddlm}|dkrH|j\}}t|||d|d|d||dS|dkr|j\}}t|||d||d|d|dSt||dS)Nr)r(r&r5)r)r(r*rr )rr+r(r<rrrr r,s    zbinomial.fdiffcCs|jr|jr|dkrt|t|}}||kr4tjS||dkrH||}tr\tt||S||d}}td|dD]}|d7}|||}qxt|S||d}}td|dD]}|d7}||9}q|t |SdS)Nrr5r&) rIr7rrarr rZbincoefrL _factorial)rr<rrerOrPrrr rs&  zbinomial._evalcCstt||f\}}||}|j|j}}|js@|s:|dkrF|jrFtjS|djsf|s\|dkrj|djrj|S|jr|js|r|r|jrtjS|j r| ||}|r|j ddS|SnN|dkr|rtj S|j rddl m}||d||d|||dSdS)NFr&T)basicrrj)rcrr_r^rFrrGrJraZ is_numberrexpandrKr)r')r;r<rreZn_nonnegZn_isintrUr'rrr rRs,   z binomial.evalcCs|j\}}tdd|||fDr*tdtdd|||fDrtt||f\}}t|d}}|dkrrtjS|dkr| |d}|drdnd}||krtjS|j }t|}|r||kr||}}|s|r|t |||||}||||}}qn||} || kr$| |}} d} t d|dD]} | | |} q6| } t |d| dD]} | | |} q`|| 9}t | d|dD]} || |}q|t | | ||d|9}||;}ntt |} td|dD]}|||kr|||}n||dkrqn|| krB||||kr|||}nt||}}d}}|dkrt|||||k}||||}}||7}qT|dkr|t |||9}||;}qt||SdS) Ncss|]}|jdkVqdS)FN)r^.0rwrrr sz%binomial._eval_Mod..z"Integers expected for binomial Modcss|] }|jVqdSr)rIrrrr rsr&rr5r\)r*anyrallrcr7r`rrarbrrLrSr8rr9)rr@r<rrdrUrfr=KreZkfrPZdfMr>rarrr rhsl             zbinomial._eval_ModcKs|jd}|jrt|jS|jd}||jr6||}|jr|jrHtjS|jrTtjS|jdd}}t d|dD]}||||9}qr|t |Sn t|jSdS)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&N) r*rErrIrFrrGrJrarLr)rhintsr<rrOrPrrr _eval_expand_funcs     zbinomial._eval_expand_funccKst|t|t||Sr)rrr<rrrrr r/sz#binomial._eval_rewrite_as_factorialTcKs4ddlm}||d||d|||dSrirk)rr<rrlrr'rrr rm2s zbinomial._eval_rewrite_as_gammaNcKs|||dS)Nr)rmr)rr<rrrrrr r6sz#binomial._eval_rewrite_as_tractablecKs|jrt||t|SdSr)r^ffrrrrr r9sz*binomial._eval_rewrite_as_FallingFactorialcCs,|j\}}|jr|jrdS|jdkr(dSdSNTF)r*r^rr<rrrr rt=s    zbinomial._eval_is_integercCs>|j\}}|jr:|jr:|js(|js(|jr,dS|jdkr:dSdSr)r*r^r_rJrrrrr rDs    zbinomial._eval_is_nonnegativercCs"ddlm}||j|||dS)Nrrj)r~r)r)r'rr)rrwr~rr'rrr rLs zbinomial._eval_as_leading_term)r&)T)N)Nr)r"r#r$r%r,rrrRrhrrrmrrrtrrrrrr r3sM   P  rN)- __future__r functoolsrZ sympy.corerrrrZsympy.core.cacherZsympy.core.functionr r r Zsympy.core.logicr Zsympy.core.numbersr rrZsympy.core.relationalrZsympy.external.gmpyrrZ sympy.ntheoryrZsympy.polys.polytoolsrmathrrrrr8rrrrrrrrrrrrr s0       nbx"