o 3Ih+0@stdZddlmZmZddlmZddlmZddlm Z ddl m Z m Z ddl mZddlmZmZmZd d ZGd d d eZd dZGdddeZe dZddZGdddeZddZGdddeZddZGdddeZe dZdd ZGd!d"d"eZ d#d$Z!Gd%d&d&eZ"d'd(Z#Gd)d*d*eZ$d+d,Z%Gd-d.d.eZ&Gd/d0d0eZ'Gd1d2d2eZ(d3S)4a# This module contains SymPy functions mathcin corresponding to special math functions in the C standard library (since C99, also available in C++11). The functions defined in this module allows the user to express functions such as ``expm1`` as a SymPy function for symbolic manipulation. )ArgumentIndexErrorFunction)Rational)Pow)S)explog)sqrt)BooleanFunctiontruefalsecCst|tjSNrrOnexrX/home/air/sanwanet/gpt-api/venv/lib/python3.10/site-packages/sympy/codegen/cfunctions.py_expm1rc@sNeZdZdZdZdddZddZddZeZe d d Z d d Z d dZ dS)expm1a* Represents the exponential function minus one. Explanation =========== The benefit of using ``expm1(x)`` over ``exp(x) - 1`` is that the latter is prone to cancellation under finite precision arithmetic when x is close to zero. Examples ======== >>> from sympy.abc import x >>> from sympy.codegen.cfunctions import expm1 >>> '%.0e' % expm1(1e-99).evalf() '1e-99' >>> from math import exp >>> exp(1e-99) - 1 0.0 >>> expm1(x).diff(x) exp(x) See Also ======== log1p cCs|dkr t|jSt||@ Returns the first derivative of this function. r)rargsrselfargindexrrrfdiff4s  z expm1.fdiffcK t|jSr )rrrhintsrrr_eval_expand_func= zexpm1._eval_expand_funccKst|tjSr rrargkwargsrrr_eval_rewrite_as_exp@rzexpm1._eval_rewrite_as_expcCs t|}|dur|tjSdSr )revalrr)clsr%exp_argrrrr(Es  z expm1.evalcC |jdjSNr)ris_realrrrr _eval_is_realK zexpm1._eval_is_realcCr+r,)r is_finiter.rrr_eval_is_finiteNr0zexpm1._eval_is_finiteNr) __name__ __module__ __qualname____doc__nargsrr"r'_eval_rewrite_as_tractable classmethodr(r/r2rrrrrs    rcCst|tjSr )rrrrrrr_log1pRrr;c@sfeZdZdZdZdddZddZddZeZe d d Z d d Z d dZ ddZ ddZddZdS)log1paf Represents the natural logarithm of a number plus one. Explanation =========== The benefit of using ``log1p(x)`` over ``log(x + 1)`` is that the latter is prone to cancellation under finite precision arithmetic when x is close to zero. Examples ======== >>> from sympy.abc import x >>> from sympy.codegen.cfunctions import log1p >>> from sympy import expand_log >>> '%.0e' % expand_log(log1p(1e-99)).evalf() '1e-99' >>> from math import log >>> log(1 + 1e-99) 0.0 >>> log1p(x).diff(x) 1/(x + 1) See Also ======== expm1 rcCs(|dkrtj|jdtjSt||rrr)rrrrrrrrrws z log1p.fdiffcKrr )r;rr rrrr"r#zlog1p._eval_expand_funccKt|Sr )r;r$rrr_eval_rewrite_as_logzlog1p._eval_rewrite_as_logcCsF|jr t|tjS|jst|tjS|jr!tt|tjSdSr ) is_Rationalrrris_Floatr( is_numberrr)r%rrrr(sz log1p.evalcCs|jdtjjSr,)rrris_nonnegativer.rrrr/szlog1p._eval_is_realcCs"|jdtjjr dS|jdjS)NrF)rrris_zeror1r.rrrr2s zlog1p._eval_is_finitecCr+r,)r is_positiver.rrr_eval_is_positiver0zlog1p._eval_is_positivecCr+r,)rrFr.rrr _eval_is_zeror0zlog1p._eval_is_zerocCr+r,)rrEr.rrr_eval_is_nonnegativer0zlog1p._eval_is_nonnegativeNr3)r4r5r6r7r8rr"r?r9r:r(r/r2rHrIrJrrrrr<Vs    r<cCs tt|Sr )r_Tworrrr_exp2r#rMc@s>eZdZdZdZd ddZddZeZddZe d d Z d S) exp2a Represents the exponential function with base two. Explanation =========== The benefit of using ``exp2(x)`` over ``2**x`` is that the latter is not as efficient under finite precision arithmetic. Examples ======== >>> from sympy.abc import x >>> from sympy.codegen.cfunctions import exp2 >>> exp2(2).evalf() == 4.0 True >>> exp2(x).diff(x) log(2)*exp2(x) See Also ======== log2 rcCs|dkr |ttSt||r)rrLrrrrrrs  z exp2.fdiffcKr>r )rMr$rrr_eval_rewrite_as_Powr@zexp2._eval_rewrite_as_PowcKrr )rMrr rrrr"r#zexp2._eval_expand_funccCs|jrt|SdSr )rCrMrDrrrr(sz exp2.evalNr3) r4r5r6r7r8rrOr9r"r:r(rrrrrNs  rNcCt|ttSr )rrLrrrr_log2rQc@sFeZdZdZdZdddZeddZddZd d Z d d Z e Z d S)log2a Represents the logarithm function with base two. Explanation =========== The benefit of using ``log2(x)`` over ``log(x)/log(2)`` is that the latter is not as efficient under finite precision arithmetic. Examples ======== >>> from sympy.abc import x >>> from sympy.codegen.cfunctions import log2 >>> log2(4).evalf() == 2.0 True >>> log2(x).diff(x) 1/(x*log(2)) See Also ======== exp2 log10 rcC*|dkrtjtt|jdSt||r=)rrrrLrrrrrrr z log2.fdiffcC@|jrtj|td}|jr|SdS|jr|jtkr|jSdSdSN)base)rCrr(rLis_Atomis_PowrXrr)r%resultrrrr(z log2.evalcOs|tj|i|Sr )rewriterevalf)rrr&rrr _eval_evalfszlog2._eval_evalfcKrr )rQrr rrrr"r#zlog2._eval_expand_funccKr>r )rQr$rrrr?r@zlog2._eval_rewrite_as_logNr3) r4r5r6r7r8rr:r(r`r"r?r9rrrrrSs  rScCs |||Sr r)ryzrrr_fmar0rcc@s0eZdZdZdZd ddZddZd d d ZdS) fmaa Represents "fused multiply add". Explanation =========== The benefit of using ``fma(x, y, z)`` over ``x*y + z`` is that, under finite precision arithmetic, the former is supported by special instructions on some CPUs. Examples ======== >>> from sympy.abc import x, y, z >>> from sympy.codegen.cfunctions import fma >>> fma(x, y, z).diff(x) y rcCs.|dvr |jd|S|dkrtjSt||)rrrKrKre)rrrrrrrrr6s  z fma.fdiffcKrr )rcrr rrrr"Br#zfma._eval_expand_funcNcKr>r )rc)rr%limitvarr&rrrr9Er@zfma._eval_rewrite_as_tractabler3r )r4r5r6r7r8rr"r9rrrrrd s   rd cCrPr )r_Tenrrrr_log10LrRrjc@s>eZdZdZdZd ddZeddZddZd d Z e Z d S) log10a$ Represents the logarithm function with base ten. Examples ======== >>> from sympy.abc import x >>> from sympy.codegen.cfunctions import log10 >>> log10(100).evalf() == 2.0 True >>> log10(x).diff(x) 1/(x*log(10)) See Also ======== log2 rcCrTr=)rrrrirrrrrrrerUz log10.fdiffcCrVrW)rCrr(rirYrZrXrr[rrrr(or]z log10.evalcKrr )rjrr rrrr"xr#zlog10._eval_expand_funccKr>r )rjr$rrrr?{r@zlog10._eval_rewrite_as_logNr3) r4r5r6r7r8rr:r(r"r?r9rrrrrkPs  rkcCs t|tjSr )rrHalfrrrr_Sqrtr0rmc@2eZdZdZdZd ddZddZddZeZd S) Sqrta Represents the square root function. Explanation =========== The reason why one would use ``Sqrt(x)`` over ``sqrt(x)`` is that the latter is internally represented as ``Pow(x, S.Half)`` which may not be what one wants when doing code-generation. Examples ======== >>> from sympy.abc import x >>> from sympy.codegen.cfunctions import Sqrt >>> Sqrt(x) Sqrt(x) >>> Sqrt(x).diff(x) 1/(2*sqrt(x)) See Also ======== Cbrt rcCs,|dkrt|jdtddtSt||)rrrrKrrrrLrrrrrrs z Sqrt.fdiffcKrr )rmrr rrrr"r#zSqrt._eval_expand_funccKr>r )rmr$rrrrOr@zSqrt._eval_rewrite_as_PowNr3 r4r5r6r7r8rr"rOr9rrrrros  rocCst|tddS)Nrre)rrrrrr_CbrtrRrsc@rn) Cbrta Represents the cube root function. Explanation =========== The reason why one would use ``Cbrt(x)`` over ``cbrt(x)`` is that the latter is internally represented as ``Pow(x, Rational(1, 3))`` which may not be what one wants when doing code-generation. Examples ======== >>> from sympy.abc import x >>> from sympy.codegen.cfunctions import Cbrt >>> Cbrt(x) Cbrt(x) >>> Cbrt(x).diff(x) 1/(3*x**(2/3)) See Also ======== Sqrt rcCs0|dkrt|jdtt ddSt||)rrrrerqrrrrrs z Cbrt.fdiffcKrr )rsrr rrrr"r#zCbrt._eval_expand_funccKr>r )rsr$rrrrOr@zCbrt._eval_rewrite_as_PowNr3rrrrrrrts  rtcCstt|dt|dS)NrK)r r)rrarrr_hypotsruc@s2eZdZdZdZd ddZddZdd ZeZd S) hypota Represents the hypotenuse function. Explanation =========== The hypotenuse function is provided by e.g. the math library in the C99 standard, hence one may want to represent the function symbolically when doing code-generation. Examples ======== >>> from sympy.abc import x, y >>> from sympy.codegen.cfunctions import hypot >>> hypot(3, 4).evalf() == 5.0 True >>> hypot(x, y) hypot(x, y) >>> hypot(x, y).diff(x) x/hypot(x, y) rKrcCs4|dvrd|j|dt|j|jSt||)rrfrKr)rrLfuncrrrrrrs" z hypot.fdiffcKrr )rurr rrrr"r#zhypot._eval_expand_funccKr>r )rur$rrrrOr@zhypot._eval_rewrite_as_PowNr3rrrrrrrvs  rvc@eZdZdZeddZdS)isnanrcCs|tjurtS|jr tSdSr )rNaNr rCr rDrrrr(s z isnan.evalNr4r5r6r8r:r(rrrrryryc@rx)isinfrcCs|jrtS|jr tSdSr ) is_infiniter r1r rDrrrr('s z isinf.evalNr{rrrrr}$r|r}N))r7sympy.core.functionrrsympy.core.numbersrsympy.core.powerrsympy.core.singletonr&sympy.functions.elementary.exponentialrr(sympy.functions.elementary.miscellaneousr sympy.logic.boolalgr r r rrr;r<rLrMrNrQrSrcrdrirjrkrmrorsrtrurvryr}rrrrs<    =M4<)1./-