o 8Va*.@s@dZddlmZmZddlmZddlmZddlm 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"d.S)/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)sqrtcCst|tjSNrrOnexr:/usr/lib/python3/dist-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 )rrrZhintsrrr_eval_expand_func= zexpm1._eval_expand_funccKst|tjSr r rargkwargsrrr_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__nargsrrr"_eval_rewrite_as_tractable classmethodr#r(r+rrrrrs    rcCst|tjSr )rrr r rrr_log1pRrr4c@sfeZdZdZdZdddZddZddZeZe d d Z d d Z d dZ ddZ ddZddZdS)log1pat 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.core.function 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)rr rrrrrrrws z log1p.fdiffcKrr )r4rrrrrrrzlog1p._eval_expand_funccKt|Sr )r4rrrr_eval_rewrite_as_logzlog1p._eval_rewrite_as_logcCsF|jr t|tjS|jst|tjS|jr!tt|tjSdSr )Z is_Rationalrrr Zis_Floatr# is_numberrr$r rrrr#sz log1p.evalcCs|jdtjjSr&)rrr is_nonnegativer'rrrr(szlog1p._eval_is_realcCs"|jdtjjr dS|jdjS)NrF)rrr is_zeror*r'rrrr+s zlog1p._eval_is_finitecCr%r&)rZ is_positiver'rrr_eval_is_positiver)zlog1p._eval_is_positivecCr%r&)rr=r'rrr _eval_is_zeror)zlog1p._eval_is_zerocCr%r&)rr<r'rrr_eval_is_nonnegativer)zlog1p._eval_is_nonnegativeNr,)r-r.r/r0r1rrr8r2r3r#r(r+r>r?r@rrrrr5Vs    r5cCs tt|Sr )r_Twor rrr_exp2rrCc@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 True >>> exp2(x).diff(x) log(2)*exp2(x) See Also ======== log2 rcCs|dkr |ttSt||r)rrBrrrrrrs  z exp2.fdiffcKr7r )rCrrrr_eval_rewrite_as_Powr9zexp2._eval_rewrite_as_PowcKrr )rCrrrrrrrzexp2._eval_expand_funccCs|jrt|SdSr )r:rCr;rrrr#sz exp2.evalNr,) r-r.r/r0r1rrEr2rr3r#rrrrrDs  rDcCt|ttSr )rrBr rrr_log2rGc@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 True >>> log2(x).diff(x) 1/(x*log(2)) See Also ======== exp2 log10 rcC*|dkrtjtt|jdSt||r6)rr rrBrrrrrrr z log2.fdiffcC@|jrtj|td}|jr|SdS|jr|jtkr|jSdSdSN)base)r:rr#rBis_Atomis_PowrNrr$r resultrrrr#z log2.evalcOs|tj|i|Sr )ZrewriterZevalf)rrr!rrr _eval_evalfszlog2._eval_evalfcKrr )rGrrrrrrrzlog2._eval_expand_funccKr7r )rGrrrrr8r9zlog2._eval_rewrite_as_logNr,) r-r.r/r0r1rr3r#rTrr8r2rrrrrIs  rIcCs |||Sr r)ryzrrr_fmar)rWc@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||)rrrArArY)rrr rrrrrr6s  z fma.fdiffcKrr )rWrrrrrrBrzfma._eval_expand_funcNcKr7r )rW)rr Zlimitvarr!rrrr2Er9zfma._eval_rewrite_as_tractabler,r )r-r.r/r0r1rrr2rrrrrX s   rX cCrFr )r_Tenr rrr_log10LrHr]c@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 True >>> log10(x).diff(x) 1/(x*log(10)) See Also ======== log2 rcCrJr6)rr rr\rrrrrrrerKz log10.fdiffcCrLrM)r:rr#r\rOrPrNrrQrrrr#orSz log10.evalcKrr )r]rrrrrrxrzlog10._eval_expand_funccKr7r )r]rrrrr8{r9zlog10._eval_rewrite_as_logNr,) r-r.r/r0r1rr3r#rr8r2rrrrr^Ps  r^cCs t|tjSr )rrZHalfr rrr_Sqrtr)r_c@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||)rrrrArrrrBrrrrrrs z Sqrt.fdiffcKrr )r_rrrrrrrzSqrt._eval_expand_funccKr7r )r_rrrrrEr9zSqrt._eval_rewrite_as_PowNr, r-r.r/r0r1rrrEr2rrrrras  racCst|tddS)NrrY)rrr rrr_CbrtrHrec@r`) 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||)rrrrYrcrrrrrs z Cbrt.fdiffcKrr )rerrrrrrrzCbrt._eval_expand_funccKr7r )rerrrrrEr9zCbrt._eval_rewrite_as_PowNr,rdrrrrrfs  rfcCstt|dt|dS)NrA)r r)rrUrrr_hypotsrgc@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 True >>> hypot(x, y) hypot(x, y) >>> hypot(x, y).diff(x) x/hypot(x, y) rArcCs4|dvrd|j|dt|j|jSt||)rrZrAr)rrBfuncrrrrrrs" z hypot.fdiffcKrr )rgrrrrrrrzhypot._eval_expand_funccKr7r )rgrrrrrEr9zhypot._eval_rewrite_as_PowNr,rdrrrrrhs  rhN)#r0Zsympy.core.functionrrZsympy.core.numbersrZsympy.core.powerrZsympy.core.singletonrZ&sympy.functions.elementary.exponentialrrZ(sympy.functions.elementary.miscellaneousr rrr4r5rBrCrDrGrIrWrXr\r]r^r_rarerfrgrhrrrrs6    =M4<)1./