B
    0d                 @   s   d Z ddlZddlZddlmZmZmZmZm	Z	m
Z
 ddlmZmZmZ ddlZddlZddlmZ ddlZddlmZ ddlmZmZ d	d
dddddgZG dd deZdd Zdd Zdd Zdd Ze d! d! dZ"dd Z#dGd#d$Z$e#e$ dHd'd(Z%G d)d* d*Z&G d+d, d,Z'G d-d. d.Z(d/d0 Z)G d1d2 d2e'Z*G d3d4 d4Z+d5! e"d6< G d7d8 d8e*Z,G d9d: d:e,Z-G d;d< d<e*Z.G d=d> d>e*Z/G d?d@ d@e*Z0G dAdB dBe*Z1G dCdD dDe'Z2dEdF Z3e3d	e,Z4e3d
e-Z5e3de.Z6e3de0Z7e3de/Z8e3de1Z9e3de2Z:dS )Ia  

Nonlinear solvers
-----------------

.. currentmodule:: scipy.optimize

This is a collection of general-purpose nonlinear multidimensional
solvers. These solvers find *x* for which *F(x) = 0*. Both *x*
and *F* can be multidimensional.

Routines
~~~~~~~~

Large-scale nonlinear solvers:

.. autosummary::

   newton_krylov
   anderson

General nonlinear solvers:

.. autosummary::

   broyden1
   broyden2

Simple iterations:

.. autosummary::

   excitingmixing
   linearmixing
   diagbroyden


Examples
~~~~~~~~

**Small problem**

>>> def F(x):
...    return np.cos(x) + x[::-1] - [1, 2, 3, 4]
>>> import scipy.optimize
>>> x = scipy.optimize.broyden1(F, [1,1,1,1], f_tol=1e-14)
>>> x
array([ 4.04674914,  3.91158389,  2.71791677,  1.61756251])
>>> np.cos(x) + x[::-1]
array([ 1.,  2.,  3.,  4.])


**Large problem**

Suppose that we needed to solve the following integrodifferential
equation on the square :math:`[0,1]\times[0,1]`:

.. math::

   \nabla^2 P = 10 \left(\int_0^1\int_0^1\cosh(P)\,dx\,dy\right)^2

with :math:`P(x,1) = 1` and :math:`P=0` elsewhere on the boundary of
the square.

The solution can be found using the `newton_krylov` solver:

.. plot::

   import numpy as np
   from scipy.optimize import newton_krylov
   from numpy import cosh, zeros_like, mgrid, zeros

   # parameters
   nx, ny = 75, 75
   hx, hy = 1./(nx-1), 1./(ny-1)

   P_left, P_right = 0, 0
   P_top, P_bottom = 1, 0

   def residual(P):
       d2x = zeros_like(P)
       d2y = zeros_like(P)

       d2x[1:-1] = (P[2:]   - 2*P[1:-1] + P[:-2]) / hx/hx
       d2x[0]    = (P[1]    - 2*P[0]    + P_left)/hx/hx
       d2x[-1]   = (P_right - 2*P[-1]   + P[-2])/hx/hx

       d2y[:,1:-1] = (P[:,2:] - 2*P[:,1:-1] + P[:,:-2])/hy/hy
       d2y[:,0]    = (P[:,1]  - 2*P[:,0]    + P_bottom)/hy/hy
       d2y[:,-1]   = (P_top   - 2*P[:,-1]   + P[:,-2])/hy/hy

       return d2x + d2y - 10*cosh(P).mean()**2

   # solve
   guess = zeros((nx, ny), float)
   sol = newton_krylov(residual, guess, method='lgmres', verbose=1)
   print('Residual: %g' % abs(residual(sol)).max())

   # visualize
   import matplotlib.pyplot as plt
   x, y = mgrid[0:1:(nx*1j), 0:1:(ny*1j)]
   plt.pcolormesh(x, y, sol, shading='gouraud')
   plt.colorbar()
   plt.show()

    N)normsolveinvqrsvdLinAlgError)asarraydotvdot)get_blas_funcs)getfullargspec_no_self   )scalar_search_wolfe1scalar_search_armijobroyden1broyden2andersonlinearmixingdiagbroydenexcitingmixingnewton_krylovc               @   s   e Zd ZdS )NoConvergenceN)__name__
__module____qualname__ r   r   G/var/www/html/venv/lib/python3.7/site-packages/scipy/optimize/nonlin.pyr      s   r   c             C   s   t |  S )N)npabsolutemax)xr   r   r   maxnorm   s    r!   c             C   s*   t | } t| jtjs&t | tjdS | S )z:Return `x` as an array, of either floats or complex floats)dtype)r   r   Z
issubdtyper"   Zinexactfloat_)r    r   r   r   _as_inexact   s    r$   c             C   s(   t | t |} t|d| j}|| S )z;Return ndarray `x` as same array subclass and shape as `x0`__array_wrap__)r   Zreshapeshapegetattrr%   )r    x0wrapr   r   r   _array_like   s    r*   c             C   s"   t |  st t jS t| S )N)r   isfiniteallarrayinfr   )vr   r   r   
_safe_norm   s    r0   z
    F : function(x) -> f
        Function whose root to find; should take and return an array-like
        object.
    xin : array_like
        Initial guess for the solution
    a  
    iter : int, optional
        Number of iterations to make. If omitted (default), make as many
        as required to meet tolerances.
    verbose : bool, optional
        Print status to stdout on every iteration.
    maxiter : int, optional
        Maximum number of iterations to make. If more are needed to
        meet convergence, `NoConvergence` is raised.
    f_tol : float, optional
        Absolute tolerance (in max-norm) for the residual.
        If omitted, default is 6e-6.
    f_rtol : float, optional
        Relative tolerance for the residual. If omitted, not used.
    x_tol : float, optional
        Absolute minimum step size, as determined from the Jacobian
        approximation. If the step size is smaller than this, optimization
        is terminated as successful. If omitted, not used.
    x_rtol : float, optional
        Relative minimum step size. If omitted, not used.
    tol_norm : function(vector) -> scalar, optional
        Norm to use in convergence check. Default is the maximum norm.
    line_search : {None, 'armijo' (default), 'wolfe'}, optional
        Which type of a line search to use to determine the step size in the
        direction given by the Jacobian approximation. Defaults to 'armijo'.
    callback : function, optional
        Optional callback function. It is called on every iteration as
        ``callback(x, f)`` where `x` is the current solution and `f`
        the corresponding residual.

    Returns
    -------
    sol : ndarray
        An array (of similar array type as `x0`) containing the final solution.

    Raises
    ------
    NoConvergence
        When a solution was not found.

    )Zparams_basicZparams_extrac             C   s   | j r| j t | _ d S )N)__doc__
_doc_parts)objr   r   r   _set_doc   s    r4   krylovFarmijoTc                 sj  |
dkrt n|
}
t||||	||
d}t fdd} }t|tj}||}t|}t|}|	|
 || |dkr|dk	r|d }nd|jd  }|dkrd}n|d	krd}|d
krtdd}d}d}d}xHt|D ] }||||}|rP t||| }|j||d }t|dkr8td|rXt|||||\}}}}nd}|| }||}t|}||
 | |r||| ||d  |d  }||d  |k rt||}nt|t|||d  }|}|rtjd||
||f  tj  qW |r$tt|nd}|r\|j|||dkddd| d}t||fS t|S dS )a  
    Find a root of a function, in a way suitable for large-scale problems.

    Parameters
    ----------
    %(params_basic)s
    jacobian : Jacobian
        A Jacobian approximation: `Jacobian` object or something that
        `asjacobian` can transform to one. Alternatively, a string specifying
        which of the builtin Jacobian approximations to use:

            krylov, broyden1, broyden2, anderson
            diagbroyden, linearmixing, excitingmixing

    %(params_extra)s
    full_output : bool
        If true, returns a dictionary `info` containing convergence
        information.
    raise_exception : bool
        If True, a `NoConvergence` exception is raise if no solution is found.

    See Also
    --------
    asjacobian, Jacobian

    Notes
    -----
    This algorithm implements the inexact Newton method, with
    backtracking or full line searches. Several Jacobian
    approximations are available, including Krylov and Quasi-Newton
    methods.

    References
    ----------
    .. [KIM] C. T. Kelley, "Iterative Methods for Linear and Nonlinear
       Equations". Society for Industrial and Applied Mathematics. (1995)
       https://archive.siam.org/books/kelley/fr16/

    N)f_tolf_rtolx_tolx_rtoliterr   c                s   t  t|  S )N)r$   r*   flatten)z)Fr(   r   r   <lambda>      znonlin_solve.<locals>.<lambda>r   d   Tr6   F)Nr6   wolfezInvalid line searchg?gH.?g?gMbP?)tolr   z[Jacobian inversion yielded zero vector. This indicates a bug in the Jacobian approximation.g      ?   z%d:  |F(x)| = %g; step %g
z0A solution was found at the specified tolerance.z:The maximum number of iterations allowed has been reached.)r   rD   )nitZfunstatussuccessmessage)r!   TerminationConditionr$   r<   r   Z	full_liker.   r   
asjacobiansetupcopysize
ValueErrorrangecheckminr   _nonlin_line_searchupdater   sysstdoutwriteflushr   r*   	iteration) r>   r(   jacobianr;   verbosemaxiterr7   r8   r9   r:   Ztol_normZline_searchcallbackZfull_outputZraise_exception	conditionfuncr    dxFxFx_normgammaZeta_maxZeta_tresholdetanrF   rC   sZFx_norm_newZeta_Ainfor   )r>   r(   r   nonlin_solve   s    -




rg   :0yE>{Gz?c                s   dg|gt |d gt t   d fdd	fdd}|dkrxt|d d	|d
\}}	}
n&|dkrtd d  |d\}}	|d krd}|   |d kr̈d }n}t |}|||fS )Nr   rD   Tc                sT   | d krd S |    }|}t |d }|rP| d< |d< |d< |S )Nr   rD   )r0   )re   storeZxtr/   p)r_   r^   tmp_Fxtmp_phitmp_sr    r   r   phiy  s    z _nonlin_line_search.<locals>.phic                s0   t |  d  } | | dd |  | S )Nr   F)rj   )abs)re   ds)ro   rdiffs_normr   r   derphi  s    z#_nonlin_line_search.<locals>.derphirB   g{Gz?)Zxtolaminr6   )ru   g      ?)T)r   r   r   )r^   r    r`   r_   Zsearch_typerr   Zsminrt   re   Zphi1Zphi0ra   r   )	r_   r^   ro   rr   rs   rl   rm   rn   r    r   rR   r  s(    
rR   c               @   s.   e Zd ZdZdddddefddZdd ZdS )rI   z
    Termination condition for an iteration. It is terminated if

    - |F| < f_rtol*|F_0|, AND
    - |F| < f_tol

    AND

    - |dx| < x_rtol*|x|, AND
    - |dx| < x_tol

    Nc             C   sx   |d krt t jjd }|d kr(t j}|d kr6t j}|d krDt j}|| _|| _|| _|| _|| _	|| _
d | _d| _d S )NgUUUUUU?r   )r   finfor#   epsr.   r9   r:   r7   r8   r   r;   f0_normrX   )selfr7   r8   r9   r:   r;   r   r   r   r   __init__  s     zTerminationCondition.__init__c             C   s   |  j d7  _ | |}| |}| |}| jd kr<|| _|dkrHdS | jd k	rbd| j | jk S t|| jko|| j | jko|| jko|| j |kS )Nr   r   rD   )	rX   r   rx   r;   intr7   r8   r9   r:   )ry   fr    r_   Zf_normZx_normdx_normr   r   r   rP     s    





zTerminationCondition.check)r   r   r   r1   r!   rz   rP   r   r   r   r   rI     s   rI   c               @   s:   e Zd ZdZdd Zdd ZdddZd	d
 Zdd ZdS )Jacobiana  
    Common interface for Jacobians or Jacobian approximations.

    The optional methods come useful when implementing trust region
    etc., algorithms that often require evaluating transposes of the
    Jacobian.

    Methods
    -------
    solve
        Returns J^-1 * v
    update
        Updates Jacobian to point `x` (where the function has residual `Fx`)

    matvec : optional
        Returns J * v
    rmatvec : optional
        Returns A^H * v
    rsolve : optional
        Returns A^-H * v
    matmat : optional
        Returns A * V, where V is a dense matrix with dimensions (N,K).
    todense : optional
        Form the dense Jacobian matrix. Necessary for dense trust region
        algorithms, and useful for testing.

    Attributes
    ----------
    shape
        Matrix dimensions (M, N)
    dtype
        Data type of the matrix.
    func : callable, optional
        Function the Jacobian corresponds to

    c          	      st   ddddddddd	g	}x@|  D ]4\}}||kr<td
| |d k	r t |||  q W t drp fdd _d S )Nr   rS   matvecrmatvecrsolveZmatmattodenser&   r"   zUnknown keyword argument %sc                  s      S )N)r   r   )ry   r   r   r?     r@   z#Jacobian.__init__.<locals>.<lambda>)itemsrN   setattrhasattr	__array__)ry   kwnamesnamevaluer   )ry   r   rz     s    

zJacobian.__init__c             C   s   t | S )N)InverseJacobian)ry   r   r   r   aspreconditioner  s    zJacobian.aspreconditionerr   c             C   s   t d S )N)NotImplementedError)ry   r/   rC   r   r   r   r     s    zJacobian.solvec             C   s   d S )Nr   )ry   r    r>   r   r   r   rS     s    zJacobian.updatec             C   s:   || _ |j|jf| _|j| _| jjtjkr6| || d S )N)r^   rM   r&   r"   	__class__rK   r~   rS   )ry   r    r>   r^   r   r   r   rK     s
    zJacobian.setupN)r   )	r   r   r   r1   rz   r   r   rS   rK   r   r   r   r   r~     s   $
r~   c               @   s,   e Zd Zdd Zedd Zedd ZdS )r   c             C   s>   || _ |j| _|j| _t|dr(|j| _t|dr:|j| _d S )NrK   r   )rY   r   r   rS   r   rK   r   r   )ry   rY   r   r   r   rz   $  s    

zInverseJacobian.__init__c             C   s   | j jS )N)rY   r&   )ry   r   r   r   r&   -  s    zInverseJacobian.shapec             C   s   | j jS )N)rY   r"   )ry   r   r   r   r"   1  s    zInverseJacobian.dtypeN)r   r   r   rz   propertyr&   r"   r   r   r   r   r   #  s   	r   c          
      s  t jjjt tr S t r2t tr2  S t t	j
r jdkrPtdt	t	   jd  jd kr|tdt fdd fdd fd	d fd
d j jdS t j r jd  jd krtdt fdd fdd fdd fdd j jdS t drzt drzt drztt dt d jt dt dt d j jdS t rG  fdddt}| S t trttttttttd   S tddS )zE
    Convert given object to one suitable for use as a Jacobian.
    rD   zarray must have rank <= 2r   r   zarray must be squarec                s
   t  | S )N)r	   )r/   )Jr   r   r?   F  r@   zasjacobian.<locals>.<lambda>c                s   t   j| S )N)r	   conjT)r/   )r   r   r   r?   G  r@   c                s
   t  | S )N)r   )r/   )r   r   r   r?   H  r@   c                s   t   j| S )N)r   r   r   )r/   )r   r   r   r?   I  r@   )r   r   r   r   r"   r&   zmatrix must be squarec                s    |  S )Nr   )r/   )r   r   r   r?   N  r@   c                s      j|  S )N)r   r   )r/   )r   r   r   r?   O  r@   c                s
    | S )Nr   )r/   )r   spsolver   r   r?   P  r@   c                s      j| S )N)r   r   )r/   )r   r   r   r   r?   Q  r@   r&   r"   r   r   r   r   rS   rK   )r   r   r   r   rS   rK   r"   r&   c                   sL   e Zd Zdd Zd fdd	Z fddZd fdd		Z fd
dZdS )zasjacobian.<locals>.Jacc             S   s
   || _ d S )N)r    )ry   r    r>   r   r   r   rS   _  s    zasjacobian.<locals>.Jac.updater   c                sB    | j }t|tjr t||S tj|r6||S tdd S )NzUnknown matrix type)	r    
isinstancer   ndarrayr   scipysparse
isspmatrixrN   )ry   r/   rC   m)r   r   r   r   r   b  s    


zasjacobian.<locals>.Jac.solvec                s@    | j }t|tjr t||S tj|r4|| S tdd S )NzUnknown matrix type)	r    r   r   r   r	   r   r   r   rN   )ry   r/   r   )r   r   r   r   k  s    

zasjacobian.<locals>.Jac.matvecc                sN    | j }t|tjr&t| j|S tj	|rB| j|S t
dd S )NzUnknown matrix type)r    r   r   r   r   r   r   r   r   r   rN   )ry   r/   rC   r   )r   r   r   r   r   t  s    
zasjacobian.<locals>.Jac.rsolvec                sL    | j }t|tjr&t| j|S tj	|r@| j| S t
dd S )NzUnknown matrix type)r    r   r   r   r	   r   r   r   r   r   rN   )ry   r/   r   )r   r   r   r   }  s    
zasjacobian.<locals>.Jac.rmatvecN)r   )r   )r   r   r   rS   r   r   r   r   r   )r   r   r   r   Jac^  s
   			r   )r   r   r   r   r   r   r5   z#Cannot convert object to a JacobianN) r   r   linalgr   r   r~   inspectisclass
issubclassr   r   ndimrN   Z
atleast_2dr   r&   r"   r   r   r'   r   callablestrdictBroydenFirstBroydenSecondAndersonDiagBroydenLinearMixingExcitingMixingKrylovJacobian	TypeError)r   r   r   )r   r   r   rJ   6  sZ    






$


'rJ   c               @   s$   e Zd Zdd Zdd Zdd ZdS )GenericBroydenc             C   s`   t | ||| || _|| _t| dr\| jd kr\t|}|rVdtt|d | | _nd| _d S )Nalphag      ?r   g      ?)r~   rK   last_flast_xr   r   r   r   )ry   r(   f0r^   Znormf0r   r   r   rK     s    zGenericBroyden.setupc             C   s   t d S )N)r   )ry   r    r|   r_   dfr}   df_normr   r   r   _update  s    zGenericBroyden._updatec          	   C   s@   || j  }|| j }| ||||t|t| || _ || _d S )N)r   r   r   r   )ry   r    r|   r   r_   r   r   r   rS     s
    

zGenericBroyden.updateN)r   r   r   rK   r   rS   r   r   r   r   r     s   r   c               @   s   e Zd ZdZdd Zedd Zedd Zdd	 Zd
d Z	dddZ
dddZdd Zdd Zdd Zdd Zdd Zd ddZdS )!LowRankMatrixz
    A matrix represented as

    .. math:: \alpha I + \sum_{n=0}^{n=M} c_n d_n^\dagger

    However, if the rank of the matrix reaches the dimension of the vectors,
    full matrix representation will be used thereon.

    c             C   s(   || _ g | _g | _|| _|| _d | _d S )N)r   csrq   rd   r"   	collapsed)ry   r   rd   r"   r   r   r   rz     s    zLowRankMatrix.__init__c             C   sb   t dddg|d d | g \}}}||  }x0t||D ]"\}}	||	| }
||||j|
}q8W |S )Naxpyscaldotcr   )r   ziprM   )r/   r   r   rq   r   r   r   wcdar   r   r   _matvec  s    

zLowRankMatrix._matvecc             C   s  t |dkr| | S tddg|dd | g \}}|d }|tjt ||jd }xDt|D ]8\}}	x.t|D ]"\}
}|||
f  ||	|7  < qpW q^W tjt ||jd}x"t|D ]\}
}	||	| ||
< qW || }t||}| | }x(t||D ]\}}||||j	| }qW |S )zEvaluate w = M^-1 vr   r   r   Nr   )r"   )
lenr   r   identityr"   	enumeratezerosr   r   rM   )r/   r   r   rq   r   r   Zc0Air   jr   qr   Zqcr   r   r   _solve  s"     "
zLowRankMatrix._solvec             C   s.   | j dk	rt| j |S t|| j| j| jS )zEvaluate w = M vN)r   r   r	   r   r   r   r   rq   )ry   r/   r   r   r   r     s    
zLowRankMatrix.matvecc             C   s:   | j dk	rt| j j |S t|t| j| j| j	S )zEvaluate w = M^H vN)
r   r   r	   r   r   r   r   r   rq   r   )ry   r/   r   r   r   r     s    
zLowRankMatrix.rmatvecr   c             C   s,   | j dk	rt| j |S t|| j| j| jS )zEvaluate w = M^-1 vN)r   r   r   r   r   r   rq   )ry   r/   rC   r   r   r   r     s    
zLowRankMatrix.solvec             C   s8   | j dk	rt| j j |S t|t| j| j| j	S )zEvaluate w = M^-H vN)
r   r   r   r   r   r   r   r   rq   r   )ry   r/   rC   r   r   r   r     s    
zLowRankMatrix.rsolvec             C   sp   | j d k	r<|  j |d d d f |d d d f   7  _ d S | j| | j| t| j|jkrl|   d S )N)r   r   r   appendrq   r   rM   collapse)ry   r   r   r   r   r   r     s    
.zLowRankMatrix.appendc             C   sp   | j d k	r| j S | jtj| j| jd }xBt| j| jD ]0\}}||d d d f |d d d f 	  7 }q8W |S )N)r"   )
r   r   r   r   rd   r"   r   r   rq   r   )ry   Gmr   r   r   r   r   r     s    
,zLowRankMatrix.__array__c             C   s"   t | | _d| _d| _d| _dS )z0Collapse the low-rank matrix to a full-rank one.N)r   r-   r   r   rq   r   )ry   r   r   r   r     s    zLowRankMatrix.collapsec             C   sD   | j dk	rdS |dkstt| j|kr@| jdd= | jdd= dS )zH
        Reduce the rank of the matrix by dropping all vectors.
        Nr   )r   AssertionErrorr   r   rq   )ry   rankr   r   r   restart_reduce  s    
zLowRankMatrix.restart_reducec             C   sB   | j dk	rdS |dkstx"t| j|kr<| jd= | jd= qW dS )zK
        Reduce the rank of the matrix by dropping oldest vectors.
        Nr   )r   r   r   r   rq   )ry   r   r   r   r   simple_reduce'  s    
zLowRankMatrix.simple_reduceNc             C   s<  | j dk	rdS |}|dk	r |}n|d }| jrBt|t| jd }tdt||d }t| j}||k rldS t| jj}t| jj}t	|dd\}}t
||j }t|ddd	\}	}
}t
|t|}t
||j }xDt|D ]8}|dd|f  | j|< |dd|f  | j|< qW | j|d= | j|d= dS )
a  
        Reduce the rank of the matrix by retaining some SVD components.

        This corresponds to the "Broyden Rank Reduction Inverse"
        algorithm described in [1]_.

        Note that the SVD decomposition can be done by solving only a
        problem whose size is the effective rank of this matrix, which
        is viable even for large problems.

        Parameters
        ----------
        max_rank : int
            Maximum rank of this matrix after reduction.
        to_retain : int, optional
            Number of SVD components to retain when reduction is done
            (ie. rank > max_rank). Default is ``max_rank - 2``.

        References
        ----------
        .. [1] B.A. van der Rotten, PhD thesis,
           "A limited memory Broyden method to solve high-dimensional
           systems of nonlinear equations". Mathematisch Instituut,
           Universiteit Leiden, The Netherlands (2003).

           https://web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf

        NrD   r   r   Zeconomic)modeFT)Zfull_matricesZ
compute_uv)r   r   rQ   r   r   r   r-   r   rq   r   r	   r   r   r   rO   rL   )ry   max_rankZ	to_retainrk   r   r   CDRUSZWHkr   r   r   
svd_reduce2  s0    

zLowRankMatrix.svd_reduce)r   )r   )N)r   r   r   r1   rz   staticmethodr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r     s   	


	r   a  
    alpha : float, optional
        Initial guess for the Jacobian is ``(-1/alpha)``.
    reduction_method : str or tuple, optional
        Method used in ensuring that the rank of the Broyden matrix
        stays low. Can either be a string giving the name of the method,
        or a tuple of the form ``(method, param1, param2, ...)``
        that gives the name of the method and values for additional parameters.

        Methods available:

            - ``restart``: drop all matrix columns. Has no extra parameters.
            - ``simple``: drop oldest matrix column. Has no extra parameters.
            - ``svd``: keep only the most significant SVD components.
              Takes an extra parameter, ``to_retain``, which determines the
              number of SVD components to retain when rank reduction is done.
              Default is ``max_rank - 2``.

    max_rank : int, optional
        Maximum rank for the Broyden matrix.
        Default is infinity (i.e., no rank reduction).
    Zbroyden_paramsc               @   sV   e Zd ZdZdddZdd Zdd	 ZdddZdd ZdddZ	dd Z
dd ZdS )r   a  
    Find a root of a function, using Broyden's first Jacobian approximation.

    This method is also known as \"Broyden's good method\".

    Parameters
    ----------
    %(params_basic)s
    %(broyden_params)s
    %(params_extra)s

    See Also
    --------
    root : Interface to root finding algorithms for multivariate
           functions. See ``method=='broyden1'`` in particular.

    Notes
    -----
    This algorithm implements the inverse Jacobian Quasi-Newton update

    .. math:: H_+ = H + (dx - H df) dx^\dagger H / ( dx^\dagger H df)

    which corresponds to Broyden's first Jacobian update

    .. math:: J_+ = J + (df - J dx) dx^\dagger / dx^\dagger dx


    References
    ----------
    .. [1] B.A. van der Rotten, PhD thesis,
       \"A limited memory Broyden method to solve high-dimensional
       systems of nonlinear equations\". Mathematisch Instituut,
       Universiteit Leiden, The Netherlands (2003).

       https://web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf

    Examples
    --------
    The following functions define a system of nonlinear equations

    >>> def fun(x):
    ...     return [x[0]  + 0.5 * (x[0] - x[1])**3 - 1.0,
    ...             0.5 * (x[1] - x[0])**3 + x[1]]

    A solution can be obtained as follows.

    >>> from scipy import optimize
    >>> sol = optimize.broyden1(fun, [0, 0])
    >>> sol
    array([0.84116396, 0.15883641])

    Nrestartc                s   t  |_d _|d kr$tj}|_t|tr:d n|dd   |d }|d f   |dkrv fdd_	n@|dkr fdd_	n&|d	kr fd
d_	nt
d| d S )Nr   r   r   r   c                  s   j j  S )N)r   r   r   )reduce_paramsry   r   r   r?     r@   z'BroydenFirst.__init__.<locals>.<lambda>simplec                  s   j j  S )N)r   r   r   )r   ry   r   r   r?     r@   r   c                  s   j j  S )N)r   r   r   )r   ry   r   r   r?     r@   z"Unknown rank reduction method '%s')r   rz   r   r   r   r.   r   r   r   _reducerN   )ry   r   Zreduction_methodr   r   )r   ry   r   rz     s&    

zBroydenFirst.__init__c             C   s.   t | ||| t| j | jd | j| _d S )Nr   )r   rK   r   r   r&   r"   r   )ry   r    r>   r^   r   r   r   rK     s    zBroydenFirst.setupc             C   s
   t | jS )N)r   r   )ry   r   r   r   r     s    zBroydenFirst.todenser   c             C   s:   | j |}t| s.| | j| j| j | j |S )N)	r   r   r   r+   r,   rK   r   r   r^   )ry   r|   rC   rr   r   r   r     s    zBroydenFirst.solvec             C   s   | j |S )N)r   r   )ry   r|   r   r   r   r     s    zBroydenFirst.matvecc             C   s   | j |S )N)r   r   )ry   r|   rC   r   r   r   r     s    zBroydenFirst.rsolvec             C   s   | j |S )N)r   r   )ry   r|   r   r   r   r     s    zBroydenFirst.rmatvecc       
      C   sD   |    | j|}|| j| }|t|| }	| j||	 d S )N)r   r   r   r   r
   r   )
ry   r    r|   r_   r   r}   r   r/   r   r   r   r   r   r     s
    zBroydenFirst._update)Nr   N)r   )r   )r   r   r   r1   rz   rK   r   r   r   r   r   r   r   r   r   r   r     s   4


r   c               @   s   e Zd ZdZdd ZdS )r   aL  
    Find a root of a function, using Broyden's second Jacobian approximation.

    This method is also known as "Broyden's bad method".

    Parameters
    ----------
    %(params_basic)s
    %(broyden_params)s
    %(params_extra)s

    See Also
    --------
    root : Interface to root finding algorithms for multivariate
           functions. See ``method=='broyden2'`` in particular.

    Notes
    -----
    This algorithm implements the inverse Jacobian Quasi-Newton update

    .. math:: H_+ = H + (dx - H df) df^\dagger / ( df^\dagger df)

    corresponding to Broyden's second method.

    References
    ----------
    .. [1] B.A. van der Rotten, PhD thesis,
       "A limited memory Broyden method to solve high-dimensional
       systems of nonlinear equations". Mathematisch Instituut,
       Universiteit Leiden, The Netherlands (2003).

       https://web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf

    Examples
    --------
    The following functions define a system of nonlinear equations

    >>> def fun(x):
    ...     return [x[0]  + 0.5 * (x[0] - x[1])**3 - 1.0,
    ...             0.5 * (x[1] - x[0])**3 + x[1]]

    A solution can be obtained as follows.

    >>> from scipy import optimize
    >>> sol = optimize.broyden2(fun, [0, 0])
    >>> sol
    array([0.84116365, 0.15883529])

    c       
      C   s:   |    |}|| j| }||d  }	| j||	 d S )NrD   )r   r   r   r   )
ry   r    r|   r_   r   r}   r   r/   r   r   r   r   r   r   0  s
    zBroydenSecond._updateN)r   r   r   r1   r   r   r   r   r   r     s   1r   c               @   s4   e Zd ZdZdddZddd	Zd
d Zdd ZdS )r   a  
    Find a root of a function, using (extended) Anderson mixing.

    The Jacobian is formed by for a 'best' solution in the space
    spanned by last `M` vectors. As a result, only a MxM matrix
    inversions and MxN multiplications are required. [Ey]_

    Parameters
    ----------
    %(params_basic)s
    alpha : float, optional
        Initial guess for the Jacobian is (-1/alpha).
    M : float, optional
        Number of previous vectors to retain. Defaults to 5.
    w0 : float, optional
        Regularization parameter for numerical stability.
        Compared to unity, good values of the order of 0.01.
    %(params_extra)s

    See Also
    --------
    root : Interface to root finding algorithms for multivariate
           functions. See ``method=='anderson'`` in particular.

    References
    ----------
    .. [Ey] V. Eyert, J. Comp. Phys., 124, 271 (1996).

    Examples
    --------
    The following functions define a system of nonlinear equations

    >>> def fun(x):
    ...     return [x[0]  + 0.5 * (x[0] - x[1])**3 - 1.0,
    ...             0.5 * (x[1] - x[0])**3 + x[1]]

    A solution can be obtained as follows.

    >>> from scipy import optimize
    >>> sol = optimize.anderson(fun, [0, 0])
    >>> sol
    array([0.84116588, 0.15883789])

    N{Gz?   c             C   s2   t |  || _|| _g | _g | _d | _|| _d S )N)r   rz   r   Mr_   r   rb   w0)ry   r   r   r   r   r   r   rz     s    
zAnderson.__init__r   c       	      C   s   | j  | }t| j}|dkr"|S tj||jd}x$t|D ]}t| j| |||< q<W yt	| j
|}W n, tk
r   | jd d = | jd d = |S X x6t|D ]*}||| | j| | j | j|    7 }qW |S )Nr   )r"   )r   r   r_   r   emptyr"   rO   r
   r   r   r   r   )	ry   r|   rC   r_   rd   df_fr   rb   r   r   r   r   r     s     
*zAnderson.solvec          	   C   s>  | | j  }t| j}|dkr"|S tj||jd}x$t|D ]}t| j| |||< q<W tj||f|jd}xt|D ]|}xvt|D ]j}t| j| | j| |||f< ||kr| j	dkr|||f  t| j| | j| | j	d  | j  8  < qW qvW t
||}	x8t|D ],}
||	|
 | j|
 | j|
 | j    7 }q
W |S )Nr   )r"   rD   )r   r   r_   r   r   r"   rO   r
   r   r   r   )ry   r|   r_   rd   r   r   br   r   rb   r   r   r   r   r     s"    
>
,zAnderson.matvecc             C   s   | j dkrd S | j| | j| x,t| j| j krR| jd | jd q(W t| j}tj||f|jd}xbt	|D ]V}	xPt	|	|D ]B}
|	|
kr| j
d }nd}d| t| j|	 | j|
  ||	|
f< qW q|W |t|dj 7 }|| _d S )Nr   )r"   rD   r   )r   r_   r   r   r   popr   r   r"   rO   r   r
   Ztriur   r   r   )ry   r    r|   r_   r   r}   r   rd   r   r   r   wdr   r   r   r     s"    

.zAnderson._update)Nr   r   )r   )r   r   r   r1   rz   r   r   r   r   r   r   r   r   =  s
   ,
	
r   c               @   sV   e Zd ZdZdddZdd Zddd	Zd
d ZdddZdd Z	dd Z
dd ZdS )r   a-  
    Find a root of a function, using diagonal Broyden Jacobian approximation.

    The Jacobian approximation is derived from previous iterations, by
    retaining only the diagonal of Broyden matrices.

    .. warning::

       This algorithm may be useful for specific problems, but whether
       it will work may depend strongly on the problem.

    Parameters
    ----------
    %(params_basic)s
    alpha : float, optional
        Initial guess for the Jacobian is (-1/alpha).
    %(params_extra)s

    See Also
    --------
    root : Interface to root finding algorithms for multivariate
           functions. See ``method=='diagbroyden'`` in particular.

    Examples
    --------
    The following functions define a system of nonlinear equations

    >>> def fun(x):
    ...     return [x[0]  + 0.5 * (x[0] - x[1])**3 - 1.0,
    ...             0.5 * (x[1] - x[0])**3 + x[1]]

    A solution can be obtained as follows.

    >>> from scipy import optimize
    >>> sol = optimize.diagbroyden(fun, [0, 0])
    >>> sol
    array([0.84116403, 0.15883384])

    Nc             C   s   t |  || _d S )N)r   rz   r   )ry   r   r   r   r   rz     s    
zDiagBroyden.__init__c             C   s6   t | ||| tj| jd fd| j | jd| _d S )Nr   r   )r"   )r   rK   r   fullr&   r   r"   r   )ry   r    r>   r^   r   r   r   rK     s    zDiagBroyden.setupr   c             C   s   | | j  S )N)r   )ry   r|   rC   r   r   r   r   
  s    zDiagBroyden.solvec             C   s   | | j  S )N)r   )ry   r|   r   r   r   r     s    zDiagBroyden.matvecc             C   s   | | j   S )N)r   r   )ry   r|   rC   r   r   r   r     s    zDiagBroyden.rsolvec             C   s   | | j   S )N)r   r   )ry   r|   r   r   r   r     s    zDiagBroyden.rmatvecc             C   s   t | j S )N)r   diagr   )ry   r   r   r   r     s    zDiagBroyden.todensec             C   s(   |  j || j |  | |d  8  _ d S )NrD   )r   )ry   r    r|   r_   r   r}   r   r   r   r   r     s    zDiagBroyden._update)N)r   )r   )r   r   r   r1   rz   rK   r   r   r   r   r   r   r   r   r   r   r     s   '


r   c               @   sN   e Zd ZdZdddZdddZdd	 Zdd
dZdd Zdd Z	dd Z
dS )r   a  
    Find a root of a function, using a scalar Jacobian approximation.

    .. warning::

       This algorithm may be useful for specific problems, but whether
       it will work may depend strongly on the problem.

    Parameters
    ----------
    %(params_basic)s
    alpha : float, optional
        The Jacobian approximation is (-1/alpha).
    %(params_extra)s

    See Also
    --------
    root : Interface to root finding algorithms for multivariate
           functions. See ``method=='linearmixing'`` in particular.

    Nc             C   s   t |  || _d S )N)r   rz   r   )ry   r   r   r   r   rz   4  s    
zLinearMixing.__init__r   c             C   s   | | j  S )N)r   )ry   r|   rC   r   r   r   r   8  s    zLinearMixing.solvec             C   s   | | j  S )N)r   )ry   r|   r   r   r   r   ;  s    zLinearMixing.matvecc             C   s   | t | j S )N)r   r   r   )ry   r|   rC   r   r   r   r   >  s    zLinearMixing.rsolvec             C   s   | t | j S )N)r   r   r   )ry   r|   r   r   r   r   A  s    zLinearMixing.rmatvecc             C   s   t t | jd d| j S )Nr   )r   r   r   r&   r   )ry   r   r   r   r   D  s    zLinearMixing.todensec             C   s   d S )Nr   )ry   r    r|   r_   r   r}   r   r   r   r   r   G  s    zLinearMixing._update)N)r   )r   )r   r   r   r1   rz   r   r   r   r   r   r   r   r   r   r   r     s   


r   c               @   sV   e Zd ZdZdddZdd Zdd	d
Zdd ZdddZdd Z	dd Z
dd ZdS )r   a  
    Find a root of a function, using a tuned diagonal Jacobian approximation.

    The Jacobian matrix is diagonal and is tuned on each iteration.

    .. warning::

       This algorithm may be useful for specific problems, but whether
       it will work may depend strongly on the problem.

    See Also
    --------
    root : Interface to root finding algorithms for multivariate
           functions. See ``method=='excitingmixing'`` in particular.

    Parameters
    ----------
    %(params_basic)s
    alpha : float, optional
        Initial Jacobian approximation is (-1/alpha).
    alphamax : float, optional
        The entries of the diagonal Jacobian are kept in the range
        ``[alpha, alphamax]``.
    %(params_extra)s
    N      ?c             C   s    t |  || _|| _d | _d S )N)r   rz   r   alphamaxbeta)ry   r   r   r   r   r   rz   f  s    
zExcitingMixing.__init__c             C   s2   t | ||| tj| jd f| j| jd| _d S )Nr   )r"   )r   rK   r   r   r&   r   r"   r   )ry   r    r>   r^   r   r   r   rK   l  s    zExcitingMixing.setupr   c             C   s   | | j  S )N)r   )ry   r|   rC   r   r   r   r   p  s    zExcitingMixing.solvec             C   s   | | j  S )N)r   )ry   r|   r   r   r   r   s  s    zExcitingMixing.matvecc             C   s   | | j   S )N)r   r   )ry   r|   rC   r   r   r   r   v  s    zExcitingMixing.rsolvec             C   s   | | j   S )N)r   r   )ry   r|   r   r   r   r   y  s    zExcitingMixing.rmatvecc             C   s   t d| j S )Nr   )r   r   r   )ry   r   r   r   r   |  s    zExcitingMixing.todensec             C   sL   || j  dk}| j|  | j7  < | j| j| < tj| jd| j| jd d S )Nr   )out)r   r   r   r   Zclipr   )ry   r    r|   r_   r   r}   r   incrr   r   r   r     s    zExcitingMixing._update)Nr   )r   )r   )r   r   r   r1   rz   rK   r   r   r   r   r   r   r   r   r   r   r   K  s   


r   c               @   sD   e Zd ZdZdddZdd	 Zd
d ZdddZdd Zdd Z	dS )r   a  
    Find a root of a function, using Krylov approximation for inverse Jacobian.

    This method is suitable for solving large-scale problems.

    Parameters
    ----------
    %(params_basic)s
    rdiff : float, optional
        Relative step size to use in numerical differentiation.
    method : {'lgmres', 'gmres', 'bicgstab', 'cgs', 'minres'} or function
        Krylov method to use to approximate the Jacobian.
        Can be a string, or a function implementing the same interface as
        the iterative solvers in `scipy.sparse.linalg`.

        The default is `scipy.sparse.linalg.lgmres`.
    inner_maxiter : int, optional
        Parameter to pass to the "inner" Krylov solver: maximum number of
        iterations. Iteration will stop after maxiter steps even if the
        specified tolerance has not been achieved.
    inner_M : LinearOperator or InverseJacobian
        Preconditioner for the inner Krylov iteration.
        Note that you can use also inverse Jacobians as (adaptive)
        preconditioners. For example,

        >>> from scipy.optimize.nonlin import BroydenFirst, KrylovJacobian
        >>> from scipy.optimize.nonlin import InverseJacobian
        >>> jac = BroydenFirst()
        >>> kjac = KrylovJacobian(inner_M=InverseJacobian(jac))

        If the preconditioner has a method named 'update', it will be called
        as ``update(x, f)`` after each nonlinear step, with ``x`` giving
        the current point, and ``f`` the current function value.
    outer_k : int, optional
        Size of the subspace kept across LGMRES nonlinear iterations.
        See `scipy.sparse.linalg.lgmres` for details.
    inner_kwargs : kwargs
        Keyword parameters for the "inner" Krylov solver
        (defined with `method`). Parameter names must start with
        the `inner_` prefix which will be stripped before passing on
        the inner method. See, e.g., `scipy.sparse.linalg.gmres` for details.
    %(params_extra)s

    See Also
    --------
    root : Interface to root finding algorithms for multivariate
           functions. See ``method=='krylov'`` in particular.
    scipy.sparse.linalg.gmres
    scipy.sparse.linalg.lgmres

    Notes
    -----
    This function implements a Newton-Krylov solver. The basic idea is
    to compute the inverse of the Jacobian with an iterative Krylov
    method. These methods require only evaluating the Jacobian-vector
    products, which are conveniently approximated by a finite difference:

    .. math:: J v \approx (f(x + \omega*v/|v|) - f(x)) / \omega

    Due to the use of iterative matrix inverses, these methods can
    deal with large nonlinear problems.

    SciPy's `scipy.sparse.linalg` module offers a selection of Krylov
    solvers to choose from. The default here is `lgmres`, which is a
    variant of restarted GMRES iteration that reuses some of the
    information obtained in the previous Newton steps to invert
    Jacobians in subsequent steps.

    For a review on Newton-Krylov methods, see for example [1]_,
    and for the LGMRES sparse inverse method, see [2]_.

    References
    ----------
    .. [1] D.A. Knoll and D.E. Keyes, J. Comp. Phys. 193, 357 (2004).
           :doi:`10.1016/j.jcp.2003.08.010`
    .. [2] A.H. Baker and E.R. Jessup and T. Manteuffel,
           SIAM J. Matrix Anal. Appl. 26, 962 (2005).
           :doi:`10.1137/S0895479803422014`

    Examples
    --------
    The following functions define a system of nonlinear equations

    >>> def fun(x):
    ...     return [x[0] + 0.5 * x[1] - 1.0,
    ...             0.5 * (x[1] - x[0]) ** 2]

    A solution can be obtained as follows.

    >>> from scipy import optimize
    >>> sol = optimize.newton_krylov(fun, [0, 0])
    >>> sol
    array([0.66731771, 0.66536458])

    Nlgmres   
   c       	      K   sN  || _ || _ttjjjtjjjtjjjtjjj	tjjj
d||| _t|| j d| _| jtjjjkr|| jd< d| jd< | jdd n~| jtjjjkr| jdd n^| jtjjjkr|| jd< d| jd< | jd	g  | jd
d | jdd | jdd x@| D ]4\}}|ds2td| || j|dd  < qW d S )N)bicgstabgmresr   cgsminres)r[   r   Zrestrtr   r[   Zatolr   outer_kZouter_vZprepend_outer_vTZstore_outer_AvFZinner_zUnknown parameter %s   )preconditionerrr   r   r   r   r   r   r   r   r   r   getmethod	method_kw
setdefaultZgcrotmkr   
startswithrN   )	ry   rr   r   Zinner_maxiterZinner_Mr   r   keyr   r   r   r   rz     s6    




zKrylovJacobian.__init__c             C   s<   t | j }t | j }| jtd| td| | _d S )Nr   )rp   r(   r   r   rr   omega)ry   Zmxmfr   r   r   _update_diff_step  s    z KrylovJacobian._update_diff_stepc             C   sl   t |}|dkrd| S | j| }| | j||  | j | }tt|shtt|rhtd|S )Nr   z$Function returned non-finite results)	r   r   r^   r(   r   r   r,   r+   rN   )ry   r/   nvscr   r   r   r   r     s    
 zKrylovJacobian.matvecr   c             C   sH   d| j kr$| j| j|f| j \}}n | j| j|fd|i| j \}}|S )NrC   )r   r   op)ry   rhsrC   Zsolrf   r   r   r   r   $  s    
 zKrylovJacobian.solvec             C   s<   || _ || _|   | jd k	r8t| jdr8| j|| d S )NrS   )r(   r   r  r   r   rS   )ry   r    r|   r   r   r   rS   +  s    
zKrylovJacobian.updatec             C   s|   t | ||| || _|| _tjj| | _| j	d krJt
|jjd | _	|   | jd k	rxt| jdrx| j||| d S )Ng      ?rK   )r~   rK   r(   r   r   r   r   Zaslinearoperatorr  rr   r   rv   r"   rw   r  r   r   )ry   r    r|   r^   r   r   r   rK   5  s    

zKrylovJacobian.setup)Nr   r   Nr   )r   )
r   r   r   r1   rz   r  r   r   rS   rK   r   r   r   r   r     s   _ 
)


r   c             C   s   t |j}|\}}}}}}}	tt|t| d |}
ddd |
D }|rXd| }ddd |
D }|rx|d }|rtd| d}|t| ||j|d }i }|	t
  t|| ||  }|j|_t| |S )	a  
    Construct a solver wrapper with given name and Jacobian approx.

    It inspects the keyword arguments of ``jac.__init__``, and allows to
    use the same arguments in the wrapper function, in addition to the
    keyword arguments of `nonlin_solve`

    Nz, c             S   s   g | ]\}}d ||f qS )z%s=%rr   ).0r   r/   r   r   r   
<listcomp>V  s    z#_nonlin_wrapper.<locals>.<listcomp>c             S   s   g | ]\}}d ||f qS )z%s=%sr   )r  r   r/   r   r   r   r  Y  s    zUnexpected signature %sa  
def %(name)s(F, xin, iter=None %(kw)s, verbose=False, maxiter=None,
             f_tol=None, f_rtol=None, x_tol=None, x_rtol=None,
             tol_norm=None, line_search='armijo', callback=None, **kw):
    jac = %(jac)s(%(kwkw)s **kw)
    return nonlin_solve(F, xin, jac, iter, verbose, maxiter,
                        f_tol, f_rtol, x_tol, x_rtol, tol_norm, line_search,
                        callback)
)r   r   jacZkwkw)_getfullargspecrz   listr   r   joinrN   r   r   rS   globalsexecr1   r4   )r   r  	signatureargsvarargsvarkwdefaults
kwonlyargs
kwdefaults_kwargsZkw_strZkwkw_strwrappernsr^   r   r   r   _nonlin_wrapperJ  s*    	


r  )r5   NFNNNNNNr6   NFT)r6   rh   ri   );r1   rT   numpyr   Zscipy.linalgr   r   r   r   r   r   r   r	   r
   Zscipy.sparse.linalgr   Zscipy.sparser   r   Zscipy._lib._utilr   r	  Z
linesearchr   r   __all__	Exceptionr   r!   r$   r*   r0   r   stripr2   r4   rg   rR   rI   r~   r   rJ   r   r   r   r   r   r   r   r   r   r  r   r   r   r   r   r   r   r   r   r   r   <module>j   sl    

)   
  
,@D` Zq@ D.? A,





