U ZʹjK.@sPdZddlmZmZddlmZddlmZddlm Z ddl m Z m Z ddl mZdd ZGd d d eZd d ZGdddeZe dZddZGdddeZddZGdddeZddZGdddeZe dZddZGd d!d!eZd"d#ZGd$d%d%eZd&d'ZGd(d)d)eZ d*d+Z!Gd,d-d-eZ"Gd.d/d/eZ#d0S)1a# 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)sqrtcCst|tjSNrrOnexrW/var/www/html/bwave/python/venv/lib/python3.8/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 r rargkwargsrrr_eval_rewrite_as_exp@szexpm1._eval_rewrite_as_expcCs t|}|dk r|tjSdSr )revalrr )clsrZexp_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 )rrr r rrr_log1pRsr/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||dSrrrN)rr rrrrrrrwsz log1p.fdiffcKs t|jSr )r/rrrrrrszlog1p._eval_expand_funccKst|Sr )r/rrrr_eval_rewrite_as_logszlog1p._eval_rewrite_as_logcCsF|jrt|tjS|js*t|tjS|jrBtt|tjSdSr )Z is_Rationalrrr Zis_Floatr! is_numberrr"rrrrr!s z log1p.evalcCs|jdtjjSr#)rrr is_nonnegativer$rrrr%szlog1p._eval_is_realcCs"|jdtjjrdS|jdjS)NrF)rrr is_zeror&r$rrrr'szlog1p._eval_is_finitecCs |jdjSr#)rZ is_positiver$rrr_eval_is_positiveszlog1p._eval_is_positivecCs |jdjSr#)rr6r$rrr _eval_is_zeroszlog1p._eval_is_zerocCs |jdjSr#)rr5r$rrr_eval_is_nonnegativeszlog1p._eval_is_nonnegativeN)r)r(r)r*r+r,rrr2r-r.r!r%r'r7r8r9rrrrr0Vs  r0cCs tt|Sr )r_Twor rrr_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<rrrr_eval_rewrite_as_Powszexp2._eval_rewrite_as_PowcKs t|jSr )r<rrrrrrszexp2._eval_expand_funccCs|jrt|SdSr )r3r<r4rrrr!sz exp2.evalN)r) r(r)r*r+r,rr>r-rr.r!rrrrr=s r=cCst|ttSr )rr;r rrr_log2sr?c@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||dSr1)rr rr;rrrrrrrsz log2.fdiffcCs:|jr tj|td}|jr6|Sn|jr6|jtkr6|jSdSN)base)r3rr!r;is_Atomis_PowrBrr"rresultrrrr!s z log2.evalcOs|tj||Sr )ZrewriterZevalf)rrrrrr _eval_evalfszlog2._eval_evalfcKs t|jSr )r?rrrrrrszlog2._eval_expand_funccKst|Sr )r?rrrrr2szlog2._eval_rewrite_as_logN)r) r(r)r*r+r,rr.r!rGrr2r-rrrrr@s  r@cCs |||Sr r)ryzrrr_fmasrJc@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|dkr|jd|S|dkr$tjSt||dS)rrr:r:rLN)rrr rrrrrr6s z fma.fdiffcKs t|jSr )rJrrrrrrBszfma._eval_expand_funcNcKst|Sr )rJ)rrZlimitvarrrrrr-Eszfma._eval_rewrite_as_tractable)r)N)r(r)r*r+r,rrr-rrrrrK s  rK cCst|ttSr )r_Tenr rrr_log10LsrPc@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||dSr1)rr rrOrrrrrrresz log10.fdiffcCs:|jr tj|td}|jr6|Sn|jr6|jtkr6|jSdSrA)r3rr!rOrCrDrBrrErrrr!os z log10.evalcKs t|jSr )rPrrrrrrxszlog10._eval_expand_funccKst|Sr )rPrrrrr2{szlog10._eval_rewrite_as_logN)r) r(r)r*r+r,rr.r!rr2r-rrrrrQPs  rQcCs t|tjSr )rrZHalfr rrr_SqrtsrRc@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 )rRrrrrrrszSqrt._eval_expand_funccKst|Sr )rRrrrrr>szSqrt._eval_rewrite_as_PowN)r r(r)r*r+r,rrr>r-rrrrrSs  rScCst|tddS)NrrL)rrr rrr_CbrtsrWc@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)rrrrLNrUrrrrrsz Cbrt.fdiffcKs t|jSr )rWrrrrrrszCbrt._eval_expand_funccKst|Sr )rWrrrrr>szCbrt._eval_rewrite_as_PowN)rrVrrrrrXs  rXcCstt|dt|dS)Nr:)r r)rrHrrr_hypotsrYc@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|dkr*d|j|dt|j|jSt||dS)rrMr:rN)rr;funcrrrrrrs"z hypot.fdiffcKs t|jSr )rYrrrrrrszhypot._eval_expand_funccKst|Sr )rYrrrrr>szhypot._eval_rewrite_as_PowN)rrVrrrrrZs  rZc@seZdZdZdS)isnanrN)r(r)r*r,rrrrr\sr\N)$r+Zsympy.core.functionrrZsympy.core.numbersrZsympy.core.powerrZsympy.core.singletonrZ&sympy.functions.elementary.exponentialrrZ(sympy.functions.elementary.miscellaneousr rrr/r0r;r<r=r?r@rJrKrOrPrQrRrSrWrXrYrZr\rrrrs6    =M4<)1./-