\h+0SrSSKJrJr SSKJr SSKJr SSKJ r SSK J r J r SSK Jr SSKJrJrJr S r"S S \5rS r"S S\5r\ "S5rSr"SS\5rSr"SS\5rSr"SS\5r\ "S5rSr"SS\5r Sr!"SS\5r"S r#"S!S"\5r$S#r%"S$S%\5r&"S&S'\5r'"S(S)\5r(g*)+a# 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)BooleanFunctiontruefalsec:[U5[R- $NrrOnexs P/var/www/auris/envauris/lib/python3.13/site-packages/sympy/codegen/cfunctions.py_expm1rs q6AEE>cR\rSrSrSrSrS SjrSrSr\r \ S5r Sr S r S rg ) 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 cHUS:Xa[UR6$[X5e0 Returns the first derivative of this function. r)rargsrselfargindexs rfdiff expm1.fdiff4s$ q= ? "$T4 4rc &[UR6$r)rrr hintss r_eval_expand_funcexpm1._eval_expand_func=tyy!!rc :[U5[R- $rrr argkwargss r_eval_rewrite_as_expexpm1._eval_rewrite_as_exp@s3x!%%rc\[R"U5nUbU[R- $gr)revalrr)clsr,exp_args rr1 expm1.evalEs(((3-  QUU? " rc4URSR$Nr)ris_realr s r _eval_is_realexpm1._eval_is_realKyy|###rc4URSR$r6)r is_finiter8s r_eval_is_finiteexpm1._eval_is_finiteNsyy|%%%rNr)__name__ __module__ __qualname____firstlineno____doc__nargsr"r'r._eval_rewrite_as_tractable classmethodr1r9r>__static_attributes__r@rrrrsA8 E5" "6## $&rrc:[U[R-5$r)r rrrs r_log1prLRs q155y>rcd\rSrSrSrSrSSjrSrSr\r \ S5r Sr S r S rS rS rS rg)log1pVa 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 rcUS:Xa1[RURS[R-- $[X5errr)rrrrrs rr" log1p.fdiffws6 q=55$))A,./ /$T4 4rc &[UR6$r)rLrr%s rr'log1p._eval_expand_funcr)rc [U5$r)rLr+s r_eval_rewrite_as_loglog1p._eval_rewrite_as_log c{rc:UR(a[U[R-5$UR(d'[R "U[R-5$UR (a%[[U5[R-5$gr) is_Rationalr rris_Floatr1 is_numberrr2r,s rr1 log1p.evals^ ??sQUU{# #88C!%%K( ( ]]x}quu,- -rcVURS[R-R$r6)rrris_nonnegativer8s rr9log1p._eval_is_reals ! quu$444rcURS[R-R(agURSR$)NrF)rrris_zeror=r8s rr>log1p._eval_is_finites3 IIaL155 ) )yy|%%%rc4URSR$r6)r is_positiver8s r_eval_is_positivelog1p._eval_is_positivesyy|'''rc4URSR$r6)rrcr8s r _eval_is_zerolog1p._eval_is_zeror;rc4URSR$r6)rr`r8s r_eval_is_nonnegativelog1p._eval_is_nonnegativesyy|***rr@NrA)rBrCrDrErFrGr"r'rVrHrIr1r9r>rgrjrmrJr@rrrNrNVsP: E5""6..5& ($+rrNc"[[U5$r)r_Twors r_exp2rrs tQ<rcF\rSrSrSrSrS SjrSr\rSr \ S5r Sr g ) 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 rcHUS:XaU[[5-$[X5er)r rqrrs rr" exp2.fdiffs$ q=D > !$T4 4rc [U5$r)rrr+s r_eval_rewrite_as_Powexp2._eval_rewrite_as_Pow Szrc &[UR6$r)rrrr%s rr'exp2._eval_expand_funcdii  rc<UR(a [U5$gr)r\rrr]s rr1 exp2.evals ==:  rr@NrA) rBrCrDrErFrGr"ryrHr'rIr1rJr@rrrtrts92 E5"6!rrtc8[U5[[5- $r)r rqrs r_log2r q6#d) rcL\rSrSrSrSrS Sjr\S5rSr Sr Sr \ r S r g ) 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 rcUS:Xa0[R[[5URS-- $[ X5erQ)rrr rqrrrs rr" log2.fdiff6 q=55#d)DIIaL01 1$T4 4rcUR(a-[R"U[S9nUR(aU$gUR (a!UR [:Xa UR$ggN)base)r\r r1rqis_Atomis_Powrrr2r,results rr1 log2.evalL ==XXc-F~~  ZZCHH,77N-ZrcLUR[5R"U0UD6$r)rewriter evalf)r rr-s r _eval_evalflog2._eval_evalfs!||C &&777rc &[UR6$r)rrr%s rr'log2._eval_expand_funcr~rc [U5$r)rr+s rrVlog2._eval_rewrite_as_logr{rr@NrA)rBrCrDrErFrGr"rIr1rr'rVrHrJr@rrrrs>4 E58!"6rrcX-U-$rr@)ryzs r_fmars 37Nrc6\rSrSrSrSrS SjrSrS SjrSr g) fmai a\ 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 ctUS;aURSU- $US:Xa[R$[X5e)rrroror)rrrrrs rr" fma.fdiff6s: v 99Q\* * ]55L$T4 4rc &[UR6$r)rrr%s rr'fma._eval_expand_funcBsTYYrNc [U5$r)r)r r,limitvarr-s rrHfma._eval_rewrite_as_tractableEs Cyrr@rAr) rBrCrDrErFrGr"r'rHrJr@rrrr s& E 5 rr c8[U5[[5- $r)r _Tenrs r_log10rLrrcF\rSrSrSrSrS Sjr\S5rSr Sr \ r Sr g ) log10iPz 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 rcUS:Xa0[R[[5URS-- $[ X5erQ)rrr rrrrs rr" log10.fdifferrcUR(a-[R"U[S9nUR(aU$gUR (a!UR [:Xa UR$ggr)r\r r1rrrrrrs rr1 log10.evalorrc &[UR6$r)rrr%s rr'log10._eval_expand_funcxr)rc [U5$r)rr+s rrVlog10._eval_rewrite_as_log{rXrr@NrA) rBrCrDrErFrGr"rIr1r'rVrHrJr@rrrrPs9$ E5""6rrc6[U[R5$r)rrHalfrs r_Sqrtrs q!&&>rc6\rSrSrSrSrS SjrSrSr\r Sr g) Sqrtia 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 rcxUS:Xa*[URS[SS55[- $[ X5e)rrrrorrrrqrrs rr" Sqrt.fdiffs6 q=tyy|Xb!_5d: :$T4 4rc &[UR6$r)rrr%s rr'Sqrt._eval_expand_funcr~rc [U5$r)rr+s rrySqrt._eval_rewrite_as_Powr{rr@NrA rBrCrDrErFrGr"r'ryrHrJr@rrrrs%2 E5!"6rrc.[U[SS55$)Nrr)rrrs r_Cbrtrs q(1a. !!rc6\rSrSrSrSrS SjrSrSr\r Sr g) Cbrtia 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 rc~US:Xa-[URS[[*S- 55S- $[ X5e)rrrrrrs rr" Cbrt.fdiffs; q=tyy|XteAg%679 9$T4 4rc &[UR6$r)rrr%s rr'Cbrt._eval_expand_funcr~rc [U5$r)rr+s rryCbrt._eval_rewrite_as_Powr{rr@NrArr@rrrrs%2 E5!"6rrcF[[US5[US5-5$)Nro)r r)rrs r_hypotrs Aq C1I% &&rc6\rSrSrSrSrS SjrSrSr\r Sr g) hypotia 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) rocUS;a6SURUS- -[UR"UR6-- $[X5e)rrror)rrqfuncrrs rr" hypot.fdiffsF v TYYxz**DDII1F,FG G$T4 4rc &[UR6$r)rrr%s rr'hypot._eval_expand_funcr)rc [U5$r)rr+s rryhypot._eval_rewrite_as_PowrXrr@NrArr@rrrrs%. E5""6rrc(\rSrSrSr\S5rSrg)isnanircdU[RLa[$UR(a[$gr)rNaNr r\r r]s rr1 isnan.evals! !%%<K ]]Lrr@NrBrCrDrErGrIr1rJr@rrrr Errc(\rSrSrSr\S5rSrg)isinfi$rc`UR(a[$UR(a[$gr) is_infiniter r=r r]s rr1 isinf.eval's ??K ]]Lrr@Nrr@rrrr$rrrN))rFsympy.core.functionrrsympy.core.numbersrsympy.core.powerrsympy.core.singletonr&sympy.functions.elementary.exponentialrr (sympy.functions.elementary.miscellaneousr sympy.logic.boolalgr r r rrrLrNrqrrrtrrrrrrrrrrrrrrrr@rrrs=' ";9<<:&H:&zK+HK+Z t181h96896x&(&R u.6H.6b+68+6\",68,6^'*6H*6Z O  O r