o e$.@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|tjSNrrOnexrHD:\Projects\ConvertPro\env\Lib\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 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_log1pRrr5c@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)rr rrrrrrrws z log1p.fdiffcKrr )r5rrrrrrrzlog1p._eval_expand_funccKt|Sr )r5r rrr_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/r0r1r2rrr9r3r4r$r)r,r?r@rArrrrr6Vs    r6cCs tt|Sr )r_Twor rrr_exp2rrDc@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)rrCrrrrrrs  z exp2.fdiffcKr8r )rDr rrr_eval_rewrite_as_Powr:zexp2._eval_rewrite_as_PowcKrr )rDrrrrrrrzexp2._eval_expand_funccCs|jrt|SdSr )r;rDr<rrrr$sz exp2.evalNr-) r.r/r0r1r2rrFr3rr4r$rrrrrEs  rEcCt|ttSr )rrCr rrr_log2rHc@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||r7)rr rrCrrrrrrr z log2.fdiffcC@|jrtj|td}|jr|SdS|jr|jtkr|jSdSdSN)base)r;rr$rCis_Atomis_PowrOrr%r!resultrrrr$z log2.evalcOs|tj|i|Sr )ZrewriterZevalf)rrr"rrr _eval_evalfszlog2._eval_evalfcKrr )rHrrrrrrrzlog2._eval_expand_funccKr8r )rHr rrrr9r:zlog2._eval_rewrite_as_logNr-) r.r/r0r1r2rr4r$rUrr9r3rrrrrJs  rJcCs |||Sr r)ryzrrr_fmar*rXc@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||)rrrBrBrZ)rrr rrrrrr6s  z fma.fdiffcKrr )rXrrrrrrBrzfma._eval_expand_funcNcKr8r )rX)rr!Zlimitvarr"rrrr3Er:zfma._eval_rewrite_as_tractabler-r )r.r/r0r1r2rrr3rrrrrY s   rY cCrGr )r_Tenr rrr_log10LrIr^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.0 True >>> log10(x).diff(x) 1/(x*log(10)) See Also ======== log2 rcCrKr7)rr rr]rrrrrrrerLz log10.fdiffcCrMrN)r;rr$r]rPrQrOrrRrrrr$orTz log10.evalcKrr )r^rrrrrrxrzlog10._eval_expand_funccKr8r )r^r rrrr9{r:zlog10._eval_rewrite_as_logNr-) r.r/r0r1r2rr4r$rr9r3rrrrr_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||)rrrrBrrrrCrrrrrrs z Sqrt.fdiffcKrr )r`rrrrrrrzSqrt._eval_expand_funccKr8r )r`r rrrrFr:zSqrt._eval_rewrite_as_PowNr- r.r/r0r1r2rrrFr3rrrrrbs  rbcCst|tddS)NrrZ)rrr rrr_CbrtrIrfc@ra) 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||)rrrrZrdrrrrrs z Cbrt.fdiffcKrr )rfrrrrrrrzCbrt._eval_expand_funccKr8r )rfr rrrrFr:zCbrt._eval_rewrite_as_PowNr-rerrrrrgs  rgcCstt|dt|dS)NrB)r r)rrVrrr_hypotsrhc@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) rBrcCs4|dvrd|j|dt|j|jSt||)rr[rBr)rrCfuncrrrrrrs" z hypot.fdiffcKrr )rhrrrrrrrzhypot._eval_expand_funccKr8r )rhr rrrrFr:zhypot._eval_rewrite_as_PowNr-rerrrrris  riN)#r1Zsympy.core.functionrrZsympy.core.numbersrZsympy.core.powerrZsympy.core.singletonrZ&sympy.functions.elementary.exponentialrrZ(sympy.functions.elementary.miscellaneousr rrr5r6rCrDrErHrJrXrYr]r^r_r`rbrfrgrhrirrrrs6    =M4<)1./