a kh+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|tjSNrrOnexrF/var/www/auris/lib/python3.9/site-packages/sympy/codegen/cfunctions.py_expm1src@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 |dkrt|jSt||dS@ Returns the first derivative of this function. rN)rargsrselfZargindexrrrfdiff4s z expm1.fdiffcKs t|jSr )rrrhintsrrr_eval_expand_func=szexpm1._eval_expand_funccKst|tjSr rrargkwargsrrr_eval_rewrite_as_exp@szexpm1._eval_rewrite_as_expcCs t|}|dur|tjSdSr )revalrr)clsr!Zexp_argrrrr$Es z expm1.evalcCs |jdjSNr)rZis_realrrrr _eval_is_realKszexpm1._eval_is_realcCs |jdjSr&)r is_finiter'rrr_eval_is_finiteNszexpm1._eval_is_finiteN)r) __name__ __module__ __qualname____doc__nargsrrr#_eval_rewrite_as_tractable classmethodr$r(r*rrrrrs  rcCst|tjSr )rrrrrrr_log1pRsr2c@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||dSrrrN)rrrrrrrrrwsz log1p.fdiffcKs t|jSr )r2rrrrrrszlog1p._eval_expand_funccKst|Sr )r2r rrr_eval_rewrite_as_logszlog1p._eval_rewrite_as_logcCsF|jrt|tjS|js*t|tjS|jrBtt|tjSdSr )Z is_RationalrrrZis_Floatr$ is_numberrr%r!rrrr$s z log1p.evalcCs|jdtjjSr&)rrris_nonnegativer'rrrr(szlog1p._eval_is_realcCs"|jdtjjrdS|jdjS)NrF)rrris_zeror)r'rrrr*szlog1p._eval_is_finitecCs |jdjSr&)rZ is_positiver'rrr_eval_is_positiveszlog1p._eval_is_positivecCs |jdjSr&)rr9r'rrr _eval_is_zeroszlog1p._eval_is_zerocCs |jdjSr&)rr8r'rrr_eval_is_nonnegativeszlog1p._eval_is_nonnegativeN)r)r+r,r-r.r/rrr5r0r1r$r(r*r:r;r<rrrrr3Vs  r3cCs tt|Sr )r_Tworrrr_exp2sr?c@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||dSr)rr>rrrrrrs z exp2.fdiffcKst|Sr )r?r rrr_eval_rewrite_as_Powszexp2._eval_rewrite_as_PowcKs t|jSr )r?rrrrrrszexp2._eval_expand_funccCs|jrt|SdSr )r6r?r7rrrr$sz exp2.evalN)r) r+r,r-r.r/rrAr0rr1r$rrrrr@s r@cCst|ttSr )rr>rrrr_log2srBc@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 rcCs.|dkr tjtt|jdSt||dSr4)rrrr>rrrrrrrsz log2.fdiffcCs:|jr tj|td}|jr6|Sn|jr6|jtkr6|jSdSN)base)r6rr$r>is_Atomis_PowrErr%r!resultrrrr$s z log2.evalcOs|tj|i|Sr )ZrewriterZevalf)rrr"rrr _eval_evalfszlog2._eval_evalfcKs t|jSr )rBrrrrrrszlog2._eval_expand_funccKst|Sr )rBr rrrr5szlog2._eval_rewrite_as_logN)r) r+r,r-r.r/rr1r$rJrr5r0rrrrrCs  rCcCs |||Sr r)ryzrrr_fmasrMc@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 rcCs2|dvr|jd|S|dkr$tjSt||dS)rrr=r=rON)rrrrrrrrr6s z fma.fdiffcKs t|jSr )rMrrrrrrBszfma._eval_expand_funcNcKst|Sr )rM)rr!Zlimitvarr"rrrr0Eszfma._eval_rewrite_as_tractable)r)N)r+r,r-r.r/rrr0rrrrrN s  rN cCst|ttSr )r_Tenrrrr_log10LsrSc@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 rcCs.|dkr tjtt|jdSt||dSr4)rrrrRrrrrrrresz log10.fdiffcCs:|jr tj|td}|jr6|Sn|jr6|jtkr6|jSdSrD)r6rr$rRrFrGrErrHrrrr$os z log10.evalcKs t|jSr )rSrrrrrrxszlog10._eval_expand_funccKst|Sr )rSr rrrr5{szlog10._eval_rewrite_as_logN)r) r+r,r-r.r/rr1r$rr5r0rrrrrTPs  rTcCs t|tjSr )rrZHalfrrrr_SqrtsrUc@s2eZdZdZdZd 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 rcCs0|dkr"t|jdtddtSt||dS)rrrr=Nrrrr>rrrrrrsz Sqrt.fdiffcKs t|jSr )rUrrrrrrszSqrt._eval_expand_funccKst|Sr )rUr rrrrAszSqrt._eval_rewrite_as_PowN)r r+r,r-r.r/rrrAr0rrrrrVs  rVcCst|tddS)NrrO)rrrrrr_CbrtsrZc@s2eZdZdZdZd ddZddZddZeZd S) 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 rcCs4|dkr&t|jdtt ddSt||dS)rrrrONrXrrrrrsz Cbrt.fdiffcKs t|jSr )rZrrrrrrszCbrt._eval_expand_funccKst|Sr )rZr rrrrAszCbrt._eval_rewrite_as_PowN)rrYrrrrr[s  r[cCstt|dt|dS)Nr=)r r)rrKrrr_hypotsr\c@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) r=rcCs8|dvr*d|j|dt|j|jSt||dS)rrPr=rN)rr>funcrrrrrrs"z hypot.fdiffcKs t|jSr )r\rrrrrrszhypot._eval_expand_funccKst|Sr )r\r rrrrAszhypot._eval_rewrite_as_PowN)rrYrrrrr]s  r]c@seZdZdZeddZdS)isnanrcCs |tjurtS|jrtSdSdSr )rNaNr r6r r7rrrr$s  z isnan.evalNr+r,r-r/r1r$rrrrr_sr_c@seZdZdZeddZdS)isinfrcCs|jr tS|jrtSdSdSr ) is_infiniter r)r r7rrrr$'s z isinf.evalNrarrrrrb$srbN))r.Zsympy.core.functionrrZsympy.core.numbersrZsympy.core.powerrZsympy.core.singletonrZ&sympy.functions.elementary.exponentialrrZ(sympy.functions.elementary.miscellaneousr Zsympy.logic.boolalgr r r rrr2r3r>r?r@rBrCrMrNrRrSrTrUrVrZr[r\r]r_rbrrrrs:    =M4<)1./-