o o hK.@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|tjSNrrOnexrl/var/www/html/construction_image-detection-poc/venv/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)rargsrselfargindexrrrfdiff4s  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"exp_argrrrr%Es  z expm1.evalcC |jdjSNr)ris_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_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)rr rrrrrrrws z log1p.fdiffcKrr )r8rrrrrrr zlog1p._eval_expand_funccKt|Sr )r8r!rrr_eval_rewrite_as_logzlog1p._eval_rewrite_as_logcCsF|jr t|tjS|jst|tjS|jr!tt|tjSdSr ) is_Rationalrrr is_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))r is_positiver+rrr_eval_is_positiver-zlog1p._eval_is_positivecCr(r))rrCr+rrr _eval_is_zeror-zlog1p._eval_is_zerocCr(r))rrBr+rrr_eval_is_nonnegativer-zlog1p._eval_is_nonnegativeNr0)r1r2r3r4r5rrr<r6r7r%r,r/rErFrGrrrrr9Vs    r9cCs tt|Sr )r_Twor rrr_exp2r rJc@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)rrIrrrrrrs  z exp2.fdiffcKr;r )rJr!rrr_eval_rewrite_as_Powr=zexp2._eval_rewrite_as_PowcKrr )rJrrrrrrr zexp2._eval_expand_funccCs|jrt|SdSr )r@rJrArrrr%sz exp2.evalNr0) r1r2r3r4r5rrLr6rr7r%rrrrrKs  rKcCt|ttSr )rrIr rrr_log2rNc@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:)rr rrIrrrrrrr z log2.fdiffcC@|jrtj|td}|jr|SdS|jr|jtkr|jSdSdSN)base)r@rr%rIis_Atomis_PowrUrr&r"resultrrrr%z log2.evalcOs|tj|i|Sr )rewriterevalf)rrr#rrr _eval_evalfszlog2._eval_evalfcKrr )rNrrrrrrr zlog2._eval_expand_funccKr;r )rNr!rrrr<r=zlog2._eval_rewrite_as_logNr0) r1r2r3r4r5rr7r%r]rr<r6rrrrrPs  rPcCs |||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||)rrrHrHrb)rrr rrrrrr6s  z fma.fdiffcKrr )r`rrrrrrBr zfma._eval_expand_funcNcKr;r )r`)rr"limitvarr#rrrr6Er=zfma._eval_rewrite_as_tractabler0r )r1r2r3r4r5rrr6rrrrra s   ra cCrMr )r_Tenr rrr_log10LrOrgc@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 rcCrQr:)rr rrfrrrrrrrerRz log10.fdiffcCrSrT)r@rr%rfrVrWrUrrXrrrr%orZz log10.evalcKrr )rgrrrrrrxr zlog10._eval_expand_funccKr;r )rgr!rrrr<{r=zlog10._eval_rewrite_as_logNr0) r1r2r3r4r5rr7r%rr<r6rrrrrhPs  rhcCs t|tjSr )rrHalfr rrr_Sqrtr-rjc@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||)rrrrHrrrrIrrrrrrs z Sqrt.fdiffcKrr )rjrrrrrrr zSqrt._eval_expand_funccKr;r )rjr!rrrrLr=zSqrt._eval_rewrite_as_PowNr0 r1r2r3r4r5rrrLr6rrrrrls  rlcCst|tddS)Nrrb)rrr rrr_CbrtrOrpc@rk) 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||)rrrrbrnrrrrrs z Cbrt.fdiffcKrr )rprrrrrrr zCbrt._eval_expand_funccKr;r )rpr!rrrrLr=zCbrt._eval_rewrite_as_PowNr0rorrrrrqs  rqcCstt|dt|dS)NrH)r r)rr^rrr_hypotsrrc@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) rHrcCs4|dvrd|j|dt|j|jSt||)rrcrHr)rrIfuncrrrrrrs" z hypot.fdiffcKrr )rrrrrrrrr zhypot._eval_expand_funccKr;r )rrr!rrrrLr=zhypot._eval_rewrite_as_PowNr0rorrrrrss  rsc@seZdZdZdS)isnanrN)r1r2r3r5rrrrrusruN)$r4sympy.core.functionrrsympy.core.numbersrsympy.core.powerrsympy.core.singletonr&sympy.functions.elementary.exponentialrr(sympy.functions.elementary.miscellaneousr rrr8r9rIrJrKrNrPr`rarfrgrhrjrlrprqrrrsrurrrrs8    =M4<)1./-