a
    <b.                     @   s@  d Z ddlmZmZ ddlmZ ddlmZ ddlm	Z	 ddl
mZmZ ddlmZ dd	 ZG d
d deZdd ZG dd deZe	dZdd ZG dd deZdd ZG dd deZdd ZG dd deZe	dZdd ZG d d! d!eZd"d# ZG d$d% d%eZd&d' ZG d(d) d)eZ d*d+ Z!G d,d- d-eZ"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.

    )ArgumentIndexErrorFunction)Rational)Pow)S)explog)sqrtc                 C   s   t | tj S Nr   r   Onex r   h/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/codegen/cfunctions.py_expm1   s    r   c                   @   sN   e Zd ZdZdZdddZdd Zdd ZeZe	d	d
 Z
dd Zdd ZdS )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
       c                 C   s    |dkrt | j S t| |dS @
        Returns the first derivative of this function.
        r   N)r   argsr   selfZargindexr   r   r   fdiff4   s    
zexpm1.fdiffc                 K   s
   t | j S r
   )r   r   r   hintsr   r   r   _eval_expand_func=   s    zexpm1._eval_expand_funcc                 K   s   t |tj S r
   r   r   argkwargsr   r   r   _eval_rewrite_as_exp@   s    zexpm1._eval_rewrite_as_expc                 C   s    t |}|d ur|tj S d S r
   )r   evalr   r   )clsr   Zexp_argr   r   r   r!   E   s    
z
expm1.evalc                 C   s   | j d jS Nr   )r   Zis_realr   r   r   r   _eval_is_realK   s    zexpm1._eval_is_realc                 C   s   | j d jS r#   )r   	is_finiter$   r   r   r   _eval_is_finiteN   s    zexpm1._eval_is_finiteN)r   )__name__
__module____qualname____doc__nargsr   r   r    _eval_rewrite_as_tractableclassmethodr!   r%   r'   r   r   r   r   r      s   
	
r   c                 C   s   t | tj S r
   )r   r   r   r   r   r   r   _log1pR   s    r/   c                   @   sf   e Zd ZdZdZdddZdd Zdd ZeZe	d	d
 Z
dd Zdd Zdd Zdd Zdd ZdS )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
    r   c                 C   s,   |dkrt j| jd t j  S t| |dS r   r   r   N)r   r   r   r   r   r   r   r   r   w   s    zlog1p.fdiffc                 K   s
   t | j S r
   )r/   r   r   r   r   r   r      s    zlog1p._eval_expand_funcc                 K   s   t |S r
   )r/   r   r   r   r   _eval_rewrite_as_log   s    zlog1p._eval_rewrite_as_logc                 C   sF   |j rt|tj S |js*t|tj S |jrBtt|tj S d S r
   )Zis_Rationalr   r   r   Zis_Floatr!   	is_numberr   r"   r   r   r   r   r!      s    z
log1p.evalc                 C   s   | j d tj jS r#   )r   r   r   is_nonnegativer$   r   r   r   r%      s    zlog1p._eval_is_realc                 C   s"   | j d tj jrdS | j d jS )Nr   F)r   r   r   is_zeror&   r$   r   r   r   r'      s    zlog1p._eval_is_finitec                 C   s   | j d jS r#   )r   Zis_positiver$   r   r   r   _eval_is_positive   s    zlog1p._eval_is_positivec                 C   s   | j d jS r#   )r   r6   r$   r   r   r   _eval_is_zero   s    zlog1p._eval_is_zeroc                 C   s   | j d jS r#   )r   r5   r$   r   r   r   _eval_is_nonnegative   s    zlog1p._eval_is_nonnegativeN)r   )r(   r)   r*   r+   r,   r   r   r2   r-   r.   r!   r%   r'   r7   r8   r9   r   r   r   r   r0   V   s   


r0      c                 C   s
   t t| S r
   )r   _Twor   r   r   r   _exp2   s    r<   c                   @   s>   e Zd ZdZdZdddZdd ZeZdd Ze	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
    r   c                 C   s"   |dkr| t t S t| |dS r   )r   r;   r   r   r   r   r   r      s    z
exp2.fdiffc                 K   s   t |S r
   )r<   r   r   r   r   _eval_rewrite_as_Pow   s    zexp2._eval_rewrite_as_Powc                 K   s
   t | j S r
   )r<   r   r   r   r   r   r      s    zexp2._eval_expand_funcc                 C   s   |j rt|S d S r
   )r3   r<   r4   r   r   r   r!      s    z	exp2.evalN)r   )r(   r)   r*   r+   r,   r   r>   r-   r   r.   r!   r   r   r   r   r=      s   
	r=   c                 C   s   t | t t S r
   )r   r;   r   r   r   r   _log2   s    r?   c                   @   sF   e Zd ZdZdZdddZedd Zdd Zd	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
    r   c                 C   s.   |dkr t jtt| jd   S t| |dS r1   )r   r   r   r;   r   r   r   r   r   r   r      s    z
log2.fdiffc                 C   s:   |j r tj|td}|jr6|S n|jr6|jtkr6|jS d S N)base)r3   r   r!   r;   is_Atomis_PowrB   r   r"   r   resultr   r   r   r!     s    z	log2.evalc                 O   s   |  tj|i |S r
   )Zrewriter   Zevalf)r   r   r   r   r   r   _eval_evalf  s    zlog2._eval_evalfc                 K   s
   t | j S r
   )r?   r   r   r   r   r   r     s    zlog2._eval_expand_funcc                 K   s   t |S r
   )r?   r   r   r   r   r2     s    zlog2._eval_rewrite_as_logN)r   )r(   r)   r*   r+   r,   r   r.   r!   rG   r   r2   r-   r   r   r   r   r@      s   


r@   c                 C   s   | | | S r
   r   )r   yzr   r   r   _fma  s    rJ   c                   @   s0   e Zd ZdZdZdddZdd Zdd	d
ZdS )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

       r   c                 C   s2   |dv r| j d|  S |dkr$tjS t| |dS )r   r   r:   r:   rL   N)r   r   r   r   r   r   r   r   r   6  s
    z	fma.fdiffc                 K   s
   t | j S r
   )rJ   r   r   r   r   r   r   B  s    zfma._eval_expand_funcNc                 K   s   t |S r
   )rJ   )r   r   Zlimitvarr   r   r   r   r-   E  s    zfma._eval_rewrite_as_tractable)r   )N)r(   r)   r*   r+   r,   r   r   r-   r   r   r   r   rK      s
   
rK   
   c                 C   s   t | t t S r
   )r   _Tenr   r   r   r   _log10L  s    rP   c                   @   s>   e Zd ZdZdZdddZedd Zdd Zd	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
    r   c                 C   s.   |dkr t jtt| jd   S t| |dS r1   )r   r   r   rO   r   r   r   r   r   r   r   e  s    zlog10.fdiffc                 C   s:   |j r tj|td}|jr6|S n|jr6|jtkr6|jS d S rA   )r3   r   r!   rO   rC   rD   rB   r   rE   r   r   r   r!   o  s    z
log10.evalc                 K   s
   t | j S r
   )rP   r   r   r   r   r   r   x  s    zlog10._eval_expand_funcc                 K   s   t |S r
   )rP   r   r   r   r   r2   {  s    zlog10._eval_rewrite_as_logN)r   )r(   r)   r*   r+   r,   r   r.   r!   r   r2   r-   r   r   r   r   rQ   P  s   


rQ   c                 C   s   t | tjS r
   )r   r   ZHalfr   r   r   r   _Sqrt  s    rR   c                   @   s2   e Zd ZdZdZd
ddZdd Zdd ZeZd	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
    r   c                 C   s0   |dkr"t | jd tddt S t| |dS )r   r   r   r:   Nr   r   r   r;   r   r   r   r   r   r     s    z
Sqrt.fdiffc                 K   s
   t | j S r
   )rR   r   r   r   r   r   r     s    zSqrt._eval_expand_funcc                 K   s   t |S r
   )rR   r   r   r   r   r>     s    zSqrt._eval_rewrite_as_PowN)r   	r(   r)   r*   r+   r,   r   r   r>   r-   r   r   r   r   rS     s   
	rS   c                 C   s   t | tddS )Nr   rL   )r   r   r   r   r   r   _Cbrt  s    rW   c                   @   s2   e Zd ZdZdZd
ddZdd Zdd ZeZd	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
    r   c                 C   s4   |dkr&t | jd tt d d S t| |dS )r   r   r   rL   NrU   r   r   r   r   r     s    z
Cbrt.fdiffc                 K   s
   t | j S r
   )rW   r   r   r   r   r   r     s    zCbrt._eval_expand_funcc                 K   s   t |S r
   )rW   r   r   r   r   r>     s    zCbrt._eval_rewrite_as_PowN)r   rV   r   r   r   r   rX     s   

rX   c                 C   s   t t| dt|d S )Nr:   )r	   r   )r   rH   r   r   r   _hypot  s    rY   c                   @   s2   e Zd ZdZdZdddZdd Zdd	 ZeZd
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)

    r:   r   c                 C   s8   |dv r*d| j |d   t| j| j    S t| |dS )r   rM   r:   r   N)r   r;   funcr   r   r   r   r   r     s    "zhypot.fdiffc                 K   s
   t | j S r
   )rY   r   r   r   r   r   r     s    zhypot._eval_expand_funcc                 K   s   t |S r
   )rY   r   r   r   r   r>     s    zhypot._eval_rewrite_as_PowN)r   rV   r   r   r   r   rZ     s   

rZ   N)#r+   Zsympy.core.functionr   r   Zsympy.core.numbersr   Zsympy.core.powerr   Zsympy.core.singletonr   Z&sympy.functions.elementary.exponentialr   r   Z(sympy.functions.elementary.miscellaneousr	   r   r   r/   r0   r;   r<   r=   r?   r@   rJ   rK   rO   rP   rQ   rR   rS   rW   rX   rY   rZ   r   r   r   r   <module>   s4   =M4<)1./