← Back
Editing: _root_scalar.cpython-311.pyc
� d�c!H � � � d Z ddlZddlmZ dgZg d�Z G d� d� � Z dd �Z d � Z d � Z d � Z d� Z d� Zd� Zd� Zd� ZdS )z� Unified interfaces to root finding algorithms for real or complex scalar functions. Functions --------- - root : find a root of a scalar function. � N� )� _zeros_py� root_scalar)�bisect�brentq�brenth�ridder�toms748�newton�secant�halleyc �0 � e Zd ZdZd� Zd� Zd� Zd� Zd� ZdS )� MemoizeDera� Decorator that caches the value and derivative(s) of function each time it is called. This is a simplistic memoizer that calls and caches a single value of `f(x, *args)`. It assumes that `args` does not change between invocations. It supports the use case of a root-finder where `args` is fixed, `x` changes, and only rarely, if at all, does x assume the same value more than once.c �> � || _ d | _ d | _ d| _ d S )Nr )�fun�vals�x�n_calls)�selfr s �=/usr/lib/python3/dist-packages/scipy/optimize/_root_scalar.py�__init__zMemoizeDer.__init__ s" � ������ ������ � � � c � � | j � || j k r4 | j |g|�R � }|| _ | xj dz c_ |dd� | _ | j d S )z,Calculate f or use cached value if availableNr r )r r r r )r r �args�fgs r �__call__zMemoizeDer.__call__# sa � � �9� ��T�V� � ����!�#�d�#�#�#�B��D�F� �L�L�A� �L�L��1�1�1��D�I��y��|�r c �R � | j � || j k r | |g|�R � | j d S )z/Calculate f' or use a cached value if availableNr �r r �r r r s r �fprimezMemoizeDer.fprime- �3 � � �9� ��T�V� � � �D��N�T�N�N�N�N��y��|�r c �R � | j � || j k r | |g|�R � | j d S )z0Calculate f'' or use a cached value if availableN� r r s r �fprime2zMemoizeDer.fprime23 r! r c � � | j S )N)r )r s r �ncallszMemoizeDer.ncalls9 s � ��|�r N) �__name__� __module__� __qualname__�__doc__r r r r$ r& � r r r r si � � � � � �� �� � � � � � � � � � � � � � � � r r r+ c �V � t |t � � s|f}| �i } d} |�@t |� � s1t |� � r t | � � } d} | j }| j }nd}|�9t |� � s*t |� � rt | � � } d} | j }nd}i } dD ]*}t � � � |� � }|�|| |< �+| r| � | � � | � dd�� � |s|rd}n|� |r|rd}nd}nd }|st d � � �|� � � }ddd �} t t |� ||� � � � }n%# t $ r}t d |z � � |�d}~ww xY w|d v rXt |t t t j f� � st d|z � � �|dd� \ }} || ||fd|i| ��\ }}�n5|dv rW|�t d|z � � �|�t d|z � � �d| v r| � d� � | d< || |f|dd|d�| ��\ }}n�|dv rV|�t d|z � � �|st d|z � � �d| v r| � d� � | d< || |f||dd�| ��\ }}n�|dv rj|�t d|z � � �|st d|z � � �|st d|z � � �d| v r| � d� � | d< || |f|||d�| ��\ }}nt d |z � � �| r| j }||_ |S ) aV Find a root of a scalar function. Parameters ---------- f : callable A function to find a root of. args : tuple, optional Extra arguments passed to the objective function and its derivative(s). method : str, optional Type of solver. Should be one of - 'bisect' :ref:`(see here) <optimize.root_scalar-bisect>` - 'brentq' :ref:`(see here) <optimize.root_scalar-brentq>` - 'brenth' :ref:`(see here) <optimize.root_scalar-brenth>` - 'ridder' :ref:`(see here) <optimize.root_scalar-ridder>` - 'toms748' :ref:`(see here) <optimize.root_scalar-toms748>` - 'newton' :ref:`(see here) <optimize.root_scalar-newton>` - 'secant' :ref:`(see here) <optimize.root_scalar-secant>` - 'halley' :ref:`(see here) <optimize.root_scalar-halley>` bracket: A sequence of 2 floats, optional An interval bracketing a root. `f(x, *args)` must have different signs at the two endpoints. x0 : float, optional Initial guess. x1 : float, optional A second guess. fprime : bool or callable, optional If `fprime` is a boolean and is True, `f` is assumed to return the value of the objective function and of the derivative. `fprime` can also be a callable returning the derivative of `f`. In this case, it must accept the same arguments as `f`. fprime2 : bool or callable, optional If `fprime2` is a boolean and is True, `f` is assumed to return the value of the objective function and of the first and second derivatives. `fprime2` can also be a callable returning the second derivative of `f`. In this case, it must accept the same arguments as `f`. xtol : float, optional Tolerance (absolute) for termination. rtol : float, optional Tolerance (relative) for termination. maxiter : int, optional Maximum number of iterations. options : dict, optional A dictionary of solver options. E.g., ``k``, see :obj:`show_options()` for details. Returns ------- sol : RootResults The solution represented as a ``RootResults`` object. Important attributes are: ``root`` the solution , ``converged`` a boolean flag indicating if the algorithm exited successfully and ``flag`` which describes the cause of the termination. See `RootResults` for a description of other attributes. See also -------- show_options : Additional options accepted by the solvers root : Find a root of a vector function. Notes ----- This section describes the available solvers that can be selected by the 'method' parameter. The default is to use the best method available for the situation presented. If a bracket is provided, it may use one of the bracketing methods. If a derivative and an initial value are specified, it may select one of the derivative-based methods. If no method is judged applicable, it will raise an Exception. Arguments for each method are as follows (x=required, o=optional). +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | method | f | args | bracket | x0 | x1 | fprime | fprime2 | xtol | rtol | maxiter | options | +===============================================+===+======+=========+====+====+========+=========+======+======+=========+=========+ | :ref:`bisect <optimize.root_scalar-bisect>` | x | o | x | | | | | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | :ref:`brentq <optimize.root_scalar-brentq>` | x | o | x | | | | | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | :ref:`brenth <optimize.root_scalar-brenth>` | x | o | x | | | | | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | :ref:`ridder <optimize.root_scalar-ridder>` | x | o | x | | | | | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | :ref:`toms748 <optimize.root_scalar-toms748>` | x | o | x | | | | | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | :ref:`newton <optimize.root_scalar-newton>` | x | o | | x | | x | | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | :ref:`secant <optimize.root_scalar-secant>` | x | o | | x | x | | | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ | :ref:`halley <optimize.root_scalar-halley>` | x | o | | x | | x | x | o | o | o | o | +-----------------------------------------------+---+------+---------+----+----+--------+---------+------+------+---------+---------+ Examples -------- Find the root of a simple cubic >>> from scipy import optimize >>> def f(x): ... return (x**3 - 1) # only one real root at x = 1 >>> def fprime(x): ... return 3*x**2 The `brentq` method takes as input a bracket >>> sol = optimize.root_scalar(f, bracket=[0, 3], method='brentq') >>> sol.root, sol.iterations, sol.function_calls (1.0, 10, 11) The `newton` method takes as input a single point and uses the derivative(s). >>> sol = optimize.root_scalar(f, x0=0.2, fprime=fprime, method='newton') >>> sol.root, sol.iterations, sol.function_calls (1.0, 11, 22) The function can provide the value and derivative(s) in a single call. >>> def f_p_pp(x): ... return (x**3 - 1), 3*x**2, 6*x >>> sol = optimize.root_scalar( ... f_p_pp, x0=0.2, fprime=True, method='newton' ... ) >>> sol.root, sol.iterations, sol.function_calls (1.0, 11, 11) >>> sol = optimize.root_scalar( ... f_p_pp, x0=0.2, fprime=True, fprime2=True, method='halley' ... ) >>> sol.root, sol.iterations, sol.function_calls (1.0, 7, 8) NFT)�xtol�rtol�maxiter)� full_output�dispr r r r zIUnable to select a solver as neither bracket nor starting point provided.)r r zUnknown solver %s)r r r r r zBracket needed for %sr# r )r zx0 must not be None for %szx1 must not be None for %sr- �tol)r r r$ �x1)r z fprime must be specified for %s)r r r$ )r z fprime2 must be specified for %s)� isinstance�tuple�callable�boolr r$ r �locals�get�update� ValueError�lower�getattr�optzeros�AttributeError�list�np�ndarray�popr �function_calls)�fr �method�bracketr r$ �x0r3 r- r. r/ �options� is_memoized�kwargs�k�v�meth�map2underlying�methodc�e�a�b�r�solr s r r r = sj � �d �d�E� "� "� ��w������ �K���8�G�#4�#4�� ��=�=� ��1� � �A� �K��i�G��X�F�F��G� ��(�6�"2�"2�� ��<�<� ��1� � �A� �K��X�F�F��F� �F� (� � �� �H�H�L�L��O�O�� �=��F�1�I�� � �� � �g� � � � �M�M�d��M�/�/�/� � "� � "� �F�F� �^�� "�� &� %�F�F� %�F�F�!�� � 9�� 8� 9� 9� 9� �<�<�>�>�D� (�H�=�=�N�<��(�N�$6�$6�t�T�$B�$B�C�C���� � <� <� <��,�t�3�4�4�!�;�����<���� �B�B�B��'�D�%���#<�=�=� ?� � 4�v� =�>�>� >��r��r�{���1����A�q�6�6�t�6�v�6�6���3�3� �� � � �:� � 9�F� B�C�C� C� �:� � 9�F� B�C�C� C� �V� � � "�J�J�v� .� .�F�5�M����B� *�T�$�� �*� *�"(�*� *���3�3� �� � � �:� � 9�F� B�C�C� C�� I� � >�� G�H�H� H� �V� � � "�J�J�v� .� .�F�5�M����B� #�T�&�$� #� #�!�#� #���3�3� �� � � �:� � 9�F� B�C�C� C�� I� � >�� G�H�H� H�� J� � ?�&� H�I�I� I� �V� � � "�J�J�v� .� .�F�5�M����B�T�T�&�'�T�T�V�T�T���3�3��,�v�5�6�6�6�� %� �)�� $��� �Js �9)E# �# F�-F � Fc � � dS )a? Options ------- args : tuple, optional Extra arguments passed to the objective function. bracket: A sequence of 2 floats, optional An interval bracketing a root. `f(x, *args)` must have different signs at the two endpoints. xtol : float, optional Tolerance (absolute) for termination. rtol : float, optional Tolerance (relative) for termination. maxiter : int, optional Maximum number of iterations. options: dict, optional Specifies any method-specific options not covered above Nr+ r+ r r �_root_scalar_brentq_docrW < � � �& �Dr c � � dS �a@ Options ------- args : tuple, optional Extra arguments passed to the objective function. bracket: A sequence of 2 floats, optional An interval bracketing a root. `f(x, *args)` must have different signs at the two endpoints. xtol : float, optional Tolerance (absolute) for termination. rtol : float, optional Tolerance (relative) for termination. maxiter : int, optional Maximum number of iterations. options: dict, optional Specifies any method-specific options not covered above. Nr+ r+ r r �_root_scalar_brenth_docr[ R rX r c � � dS rZ r+ r+ r r �_root_scalar_toms748_docr] g rX r c � � dS )a Options ------- args : tuple, optional Extra arguments passed to the objective function. xtol : float, optional Tolerance (absolute) for termination. rtol : float, optional Tolerance (relative) for termination. maxiter : int, optional Maximum number of iterations. x0 : float, required Initial guess. x1 : float, required A second guess. options: dict, optional Specifies any method-specific options not covered above. Nr+ r+ r r �_root_scalar_secant_docr_ } s � �( �Dr c � � dS )a" Options ------- args : tuple, optional Extra arguments passed to the objective function and its derivative. xtol : float, optional Tolerance (absolute) for termination. rtol : float, optional Tolerance (relative) for termination. maxiter : int, optional Maximum number of iterations. x0 : float, required Initial guess. fprime : bool or callable, optional If `fprime` is a boolean and is True, `f` is assumed to return the value of derivative along with the objective function. `fprime` can also be a callable returning the derivative of `f`. In this case, it must accept the same arguments as `f`. options: dict, optional Specifies any method-specific options not covered above. Nr+ r+ r r �_root_scalar_newton_docra � s � �. �Dr c � � dS )ar Options ------- args : tuple, optional Extra arguments passed to the objective function and its derivatives. xtol : float, optional Tolerance (absolute) for termination. rtol : float, optional Tolerance (relative) for termination. maxiter : int, optional Maximum number of iterations. x0 : float, required Initial guess. fprime : bool or callable, required If `fprime` is a boolean and is True, `f` is assumed to return the value of derivative along with the objective function. `fprime` can also be a callable returning the derivative of `f`. In this case, it must accept the same arguments as `f`. fprime2 : bool or callable, required If `fprime2` is a boolean and is True, `f` is assumed to return the value of 1st and 2nd derivatives along with the objective function. `fprime2` can also be a callable returning the 2nd derivative of `f`. In this case, it must accept the same arguments as `f`. options: dict, optional Specifies any method-specific options not covered above. Nr+ r+ r r �_root_scalar_halley_docrc � s � �8 �Dr c � � dS rZ r+ r+ r r �_root_scalar_ridder_docre � rX r c � � dS rZ r+ r+ r r �_root_scalar_bisect_docrg � rX r ) r+ NNNNNNNNNN)r* �numpyrA � r r> �__all__�ROOT_SCALAR_METHODSr r rW r[ r] r_ ra rc re rg r+ r r �<module>rl s ��� � � � � � #� #� #� #� #� #� �/��5� 5� 5� �' � ' � ' � ' � ' � ' � ' � ' �T 26�%)� �.2� � |� |� |� |�~ � � �, � � �* � � �, � � �. � � �4 � � �> � � �, � � � � r
Save File
Cancel