a
    <b                     @   s   d dl mZ d dlmZ d dlmZmZ d dlmZm	Z	 d dl
mZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZ dddZdd Zd	de fd	dddZd	S )    )Tuple)oo)GtLt)DummySymbol)Abs)And)
AssignmentAddAugmentedAssignment	CodeBlockDeclarationFunctionDefinitionPrintReturnScopeWhileVariablePointerreal-q=NFc                 C   s  |du rt  }t}d}ndd }|j}|  | | }	t||	t||g}
|r~t||gd|j|}|
d |g|
dd  }
tt	||}t
t|ttdg}|dur|pt d	d
}t|d}|t
| |
t|d t|t||}t|t|
 }||g }|t| S )ay   Generates an AST for Newton-Raphson method (a root-finding algorithm).

    Explanation
    ===========

    Returns an abstract syntax tree (AST) based on ``sympy.codegen.ast`` for Netwon's
    method of root-finding.

    Parameters
    ==========

    expr : expression
    wrt : Symbol
        With respect to, i.e. what is the variable.
    atol : number or expr
        Absolute tolerance (stopping criterion)
    delta : Symbol
        Will be a ``Dummy`` if ``None``.
    debug : bool
        Whether to print convergence information during iterations
    itermax : number or expr
        Maximum number of iterations.
    counter : Symbol
        Will be a ``Dummy`` if ``None``.

    Examples
    ========

    >>> from sympy import symbols, cos
    >>> from sympy.codegen.ast import Assignment
    >>> from sympy.codegen.algorithms import newtons_method
    >>> x, dx, atol = symbols('x dx atol')
    >>> expr = cos(x) - x**3
    >>> algo = newtons_method(expr, x, atol, dx)
    >>> algo.has(Assignment(dx, -expr/expr.diff(x)))
    True

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Newton%27s_method

    Ndeltac                 S   s   | S N )xr   r   h/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/codegen/algorithms.py<lambda>A       z newtons_method.<locals>.<lambda>z{}=%12.5g {}=%12.5g\nr      )typevalueT)integer)r   r   namediffr
   r   r   formatr   r   r   r   r   r   Zdeducedappendr	   r   r   r   )exprwrtZatolr   debugZitermaxcounterZWrapperZname_dZ
delta_exprZwhl_bdyZprntreqdeclarsZ	v_counterZwhlZblckr   r   r   newtons_method   s,    .
r,   c                 C   s(   t | tr| jj} nt | tr$| j} | S r   )
isinstancer   variablesymbolr   )argr   r   r   
_symbol_ofV   s
    


r1   Znewton)r   c                K   s   |du r|f}dd |D }|du r@t d|j }| |r@d}t| |fd|i||}t|trl|j}| j	dd |D }	|	rt
dd	tt|	 td
d |D }
t|t|}tt||
||dS )a   Generates an AST for a function implementing the Newton-Raphson method.

    Parameters
    ==========

    expr : expression
    wrt : Symbol
        With respect to, i.e. what is the variable
    params : iterable of symbols
        Symbols appearing in expr that are taken as constants during the iterations
        (these will be accepted as parameters to the generated function).
    func_name : str
        Name of the generated function.
    attrs : Tuple
        Attribute instances passed as ``attrs`` to ``FunctionDefinition``.
    \*\*kwargs :
        Keyword arguments passed to :func:`sympy.codegen.algorithms.newtons_method`.

    Examples
    ========

    >>> from sympy import symbols, cos
    >>> from sympy.codegen.algorithms import newtons_method_function
    >>> from sympy.codegen.pyutils import render_as_module
    >>> x = symbols('x')
    >>> expr = cos(x) - x**3
    >>> func = newtons_method_function(expr, x)
    >>> py_mod = render_as_module(func)  # source code as string
    >>> namespace = {}
    >>> exec(py_mod, namespace, namespace)
    >>> res = eval('newton(0.5)', namespace)
    >>> abs(res - 0.865474033102) < 1e-12
    True

    See Also
    ========

    sympy.codegen.algorithms.newtons_method

    Nc                 S   s*   i | ]"}t |tr|jtd |jj qS )z(*%s))r-   r   r/   r   r"   .0pr   r   r   
<dictcomp>   s   z+newtons_method_function.<locals>.<dictcomp>Zd_r   c                 S   s   h | ]}t |qS r   )r1   r2   r   r   r   	<setcomp>   r   z*newtons_method_function.<locals>.<setcomp>zMissing symbols in params: %sz, c                 s   s   | ]}t |tV  qd S r   )r   r   r2   r   r   r   	<genexpr>   r   z*newtons_method_function.<locals>.<genexpr>)attrs)r   r"   Zhasr,   Zxreplacer-   r   bodyZfree_symbols
difference
ValueErrorjoinmapstrtupler   r   r   r   )r&   r'   params	func_namer8   r   kwargsZpointer_subsalgoZnot_in_paramsr+   r9   r   r   r   newtons_method_function^   s$    )

rD   )r   NFNN)Zsympy.core.containersr   Zsympy.core.numbersr   Zsympy.core.relationalr   r   Zsympy.core.symbolr   r   Z$sympy.functions.elementary.complexesr   Zsympy.logic.boolalgr	   Zsympy.codegen.astr
   r   r   r   r   r   r   r   r   r   r   r   r,   r1   rD   r   r   r   r   <module>   s   8  
H