o FZh+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|tjSNrrOnexrG/var/www/auris/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)rargsrselfZargindexrrrfdiff4s  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$Zexp_argrrrr'Es  z expm1.evalcC |jdjSNr)rZis_realrrrr _eval_is_realK zexpm1._eval_is_realcCr)r*)r is_finiter+rrr_eval_is_finiteNr-zexpm1._eval_is_finiteNr) __name__ __module__ __qualname____doc__nargsrr!r&_eval_rewrite_as_tractable classmethodr'r,r/rrrrrs    rcCst|tjSr )rrrrrrr_log1pRrr8c@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 )r8rrrrrr!r"zlog1p._eval_expand_funccKt|Sr )r8r#rrr_eval_rewrite_as_logzlog1p._eval_rewrite_as_logcCsF|jr t|tjS|jst|tjS|jr!tt|tjSdSr )Z is_RationalrrrZis_Floatr' is_numberrr(r$rrrr'sz log1p.evalcCs|jdtjjSr*)rrris_nonnegativer+rrrr,szlog1p._eval_is_realcCs"|jdtjjr dS|jdjS)NrF)rrris_zeror.r+rrrr/s zlog1p._eval_is_finitecCr)r*)rZ is_positiver+rrr_eval_is_positiver-zlog1p._eval_is_positivecCr)r*)rrAr+rrr _eval_is_zeror-zlog1p._eval_is_zerocCr)r*)rr@r+rrr_eval_is_nonnegativer-zlog1p._eval_is_nonnegativeNr0)r1r2r3r4r5rr!r<r6r7r'r,r/rBrCrDrrrrr9Vs    r9cCs tt|Sr )r_Tworrrr_exp2r"rGc@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)rrFrrrrrrs  z exp2.fdiffcKr;r )rGr#rrr_eval_rewrite_as_Powr=zexp2._eval_rewrite_as_PowcKrr )rGrrrrrr!r"zexp2._eval_expand_funccCs|jrt|SdSr )r>rGr?rrrr'sz exp2.evalNr0) r1r2r3r4r5rrIr6r!r7r'rrrrrHs  rHcCt|ttSr )rrFrrrr_log2rKc@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:)rrrrFrrrrrrr z log2.fdiffcC@|jrtj|td}|jr|SdS|jr|jtkr|jSdSdSN)base)r>rr'rFis_Atomis_PowrRrr(r$resultrrrr'z log2.evalcOs|tj|i|Sr )ZrewriterZevalf)rrr%rrr _eval_evalfszlog2._eval_evalfcKrr )rKrrrrrr!r"zlog2._eval_expand_funccKr;r )rKr#rrrr<r=zlog2._eval_rewrite_as_logNr0) r1r2r3r4r5rr7r'rXr!r<r6rrrrrMs  rMcCs |||Sr r)ryzrrr_fmar-r[c@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||)rrrErEr])rrrrrrrrr6s  z fma.fdiffcKrr )r[rrrrrr!Br"zfma._eval_expand_funcNcKr;r )r[)rr$Zlimitvarr%rrrr6Er=zfma._eval_rewrite_as_tractabler0r )r1r2r3r4r5rr!r6rrrrr\ s   r\ cCrJr )r_Tenrrrr_log10LrLrac@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 rcCrNr:)rrrr`rrrrrrrerOz log10.fdiffcCrPrQ)r>rr'r`rSrTrRrrUrrrr'orWz log10.evalcKrr )rarrrrrr!xr"zlog10._eval_expand_funccKr;r )rar#rrrr<{r=zlog10._eval_rewrite_as_logNr0) r1r2r3r4r5rr7r'r!r<r6rrrrrbPs  rbcCs t|tjSr )rrZHalfrrrr_Sqrtr-rcc@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||)rrrrErrrrFrrrrrrs z Sqrt.fdiffcKrr )rcrrrrrr!r"zSqrt._eval_expand_funccKr;r )rcr#rrrrIr=zSqrt._eval_rewrite_as_PowNr0 r1r2r3r4r5rr!rIr6rrrrres  recCst|tddS)Nrr])rrrrrr_CbrtrLric@rd) 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||)rrrr]rgrrrrrs z Cbrt.fdiffcKrr )rirrrrrr!r"zCbrt._eval_expand_funccKr;r )rir#rrrrIr=zCbrt._eval_rewrite_as_PowNr0rhrrrrrjs  rjcCstt|dt|dS)NrE)r r)rrYrrr_hypotsrkc@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) rErcCs4|dvrd|j|dt|j|jSt||)rr^rEr)rrFfuncrrrrrrs" z hypot.fdiffcKrr )rkrrrrrr!r"zhypot._eval_expand_funccKr;r )rkr#rrrrIr=zhypot._eval_rewrite_as_PowNr0rhrrrrrls  rlc@eZdZdZeddZdS)isnanrcCs|tjurtS|jr tSdSr )rNaNr r>r r?rrrr's z isnan.evalNr1r2r3r5r7r'rrrrroroc@rn)isinfrcCs|jrtS|jr tSdSr ) is_infiniter r.r r?rrrr''s z isinf.evalNrqrrrrrs$rrrsN))r4Zsympy.core.functionrrZsympy.core.numbersrZsympy.core.powerrZsympy.core.singletonrZ&sympy.functions.elementary.exponentialrrZ(sympy.functions.elementary.miscellaneousr Zsympy.logic.boolalgr r r rrr8r9rFrGrHrKrMr[r\r`rarbrcrerirjrkrlrorsrrrrs<    =M4<)1./-