§
    ËãßcSK  ã                   óV  — d dl Z d dlZd dlZd dlZddlmZ ddlmZmZm	Z	m
Z
 d dlmZ d dlmZ g d¢Z e j        ej        d¬	¦  «        Z	 	 dd
„Z ee¦  «        	 	 dd„¦   «         Z	 	 dd„Z ee¦  «        	 	 dd„¦   «         Z	 	 dd„Z ee¦  «        dd„¦   «         Zd„ Zd„ Zdd„ZdS )é    Né   )Únumeric)Úresult_typeÚNaNÚ
asanyarrayÚndim)Úadd_docstring)Ú	overrides)ÚlogspaceÚlinspaceÚ	geomspaceÚnumpy)Úmodulec                 ó
   — | |fS ©N© )ÚstartÚstopÚnumÚendpointÚretstepÚdtypeÚaxiss          ú:/usr/lib/python3/dist-packages/numpy/core/function_base.pyÚ_linspace_dispatcherr      ó   € à�4ˆ=Ðó    é2   TFc                 ó°  — t          j        |¦  «        }|dk     rt          d|z  ¦  «        ‚|r|dz
  n|}t          | ¦  «        dz  } t          |¦  «        dz  }t	          | |t          |¦  «        ¦  «        }|€|}d}	nt          j        |t          j        ¦  «        }	|| z
  }
t          j	        d||¬¦  «         
                    dd	t          |
¦  «        z  z   ¦  «        }|dk    rnt          j        |
¦  «        }|
|z  }|r|dk    n)t          j        |dk    ¦  «                             ¦   «         }|r||z  }|r||
z  }n ||
z  }n|r||z  }n||z  }nt          }||
z  }|| z  }|r|dk    r||d
<   |dk    rt          j        |d|¦  «        }|	rt          j        ||¬¦  «         |r|                     |d¬¦  «        |fS |                     |d¬¦  «        S )aN  
    Return evenly spaced numbers over a specified interval.

    Returns `num` evenly spaced samples, calculated over the
    interval [`start`, `stop`].

    The endpoint of the interval can optionally be excluded.

    .. versionchanged:: 1.16.0
        Non-scalar `start` and `stop` are now supported.

    .. versionchanged:: 1.20.0
        Values are rounded towards ``-inf`` instead of ``0`` when an
        integer ``dtype`` is specified. The old behavior can
        still be obtained with ``np.linspace(start, stop, num).astype(int)``

    Parameters
    ----------
    start : array_like
        The starting value of the sequence.
    stop : array_like
        The end value of the sequence, unless `endpoint` is set to False.
        In that case, the sequence consists of all but the last of ``num + 1``
        evenly spaced samples, so that `stop` is excluded.  Note that the step
        size changes when `endpoint` is False.
    num : int, optional
        Number of samples to generate. Default is 50. Must be non-negative.
    endpoint : bool, optional
        If True, `stop` is the last sample. Otherwise, it is not included.
        Default is True.
    retstep : bool, optional
        If True, return (`samples`, `step`), where `step` is the spacing
        between samples.
    dtype : dtype, optional
        The type of the output array.  If `dtype` is not given, the data type
        is inferred from `start` and `stop`. The inferred dtype will never be
        an integer; `float` is chosen even if the arguments would produce an
        array of integers.

        .. versionadded:: 1.9.0

    axis : int, optional
        The axis in the result to store the samples.  Relevant only if start
        or stop are array-like.  By default (0), the samples will be along a
        new axis inserted at the beginning. Use -1 to get an axis at the end.

        .. versionadded:: 1.16.0

    Returns
    -------
    samples : ndarray
        There are `num` equally spaced samples in the closed interval
        ``[start, stop]`` or the half-open interval ``[start, stop)``
        (depending on whether `endpoint` is True or False).
    step : float, optional
        Only returned if `retstep` is True

        Size of spacing between samples.


    See Also
    --------
    arange : Similar to `linspace`, but uses a step size (instead of the
             number of samples).
    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
                scale (a geometric progression).
    logspace : Similar to `geomspace`, but with the end points specified as
               logarithms.
    :ref:`how-to-partition`

    Examples
    --------
    >>> np.linspace(2.0, 3.0, num=5)
    array([2.  , 2.25, 2.5 , 2.75, 3.  ])
    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
    array([2. ,  2.2,  2.4,  2.6,  2.8])
    >>> np.linspace(2.0, 3.0, num=5, retstep=True)
    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)

    Graphical illustration:

    >>> import matplotlib.pyplot as plt
    >>> N = 8
    >>> y = np.zeros(N)
    >>> x1 = np.linspace(0, 10, N, endpoint=True)
    >>> x2 = np.linspace(0, 10, N, endpoint=False)
    >>> plt.plot(x1, y, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.plot(x2, y + 0.5, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.ylim([-0.5, 1])
    (-0.5, 1)
    >>> plt.show()

    r   z,Number of samples, %s, must be non-negative.r   g      ð?NF)r   )éÿÿÿÿ)r   r    )Úout©Úcopy)ÚoperatorÚindexÚ
ValueErrorr   r   ÚfloatÚ_nxÚ
issubdtypeÚintegerÚarangeÚreshaper   ÚisscalarÚanyr   ÚmoveaxisÚfloorÚastype)r   r   r   r   r   r   r   ÚdivÚdtÚinteger_dtypeÚdeltaÚyÚ_mult_inplaceÚstepÚany_step_zeros                  r   r   r      s$  € õD Œ.˜Ñ
Ô
€CØ
ˆQ‚w€wÝÐGÈ#ÑMÑNÔNÐNØÐ
(ˆ3�‰7ˆ7 S€Cõ �uÑÔ Ñ#€EÝ�tÑÔ Ñ#€Då	�U˜D¥%¨¡*¤*Ñ	-Ô	-€BØ€}ØˆØˆˆåœ u­c¬kÑ:Ô:ˆà�5‰L€EÝŒ
�1�c Ð$Ñ$Ô$×,Ò,¨U°T½DÀ¹K¼KÑ5GÑ-GÑHÔH€Að ˆQ‚w€wÝœ UÑ+Ô+ˆØ�s‰{ˆà&ÐKˆD�AŠIˆI­C¬N¸4À1º9Ñ,EÔ,E×,IÒ,IÑ,KÔ,Kð 	àð 	à�‰HˆAØð Ø�U‘
��à˜‘I��àð Ø�T‘	��à˜‘H��õ ˆà�‰Iˆàˆ�J€Aàð �C˜!’G�GØˆˆ"‰àˆq‚y€yÝŒL˜˜A˜tÑ$Ô$ˆàð ÝŒ	�!˜ÐÑÔÐàð +Ø�xŠx˜ EˆxÑ*Ô*¨DÐ0Ð0à�xŠx˜ EˆxÑ*Ô*Ð*r   c                 ó
   — | |fS r   r   )r   r   r   r   Úbaser   r   s          r   Ú_logspace_dispatcherr<   ¸   r   r   ç      $@c                 ó¬   — t          | ||||¬¦  «        }|€t          j        ||¦  «        S t          j        ||¦  «                             |d¬¦  «        S )aÑ  
    Return numbers spaced evenly on a log scale.

    In linear space, the sequence starts at ``base ** start``
    (`base` to the power of `start`) and ends with ``base ** stop``
    (see `endpoint` below).

    .. versionchanged:: 1.16.0
        Non-scalar `start` and `stop` are now supported.

    Parameters
    ----------
    start : array_like
        ``base ** start`` is the starting value of the sequence.
    stop : array_like
        ``base ** stop`` is the final value of the sequence, unless `endpoint`
        is False.  In that case, ``num + 1`` values are spaced over the
        interval in log-space, of which all but the last (a sequence of
        length `num`) are returned.
    num : integer, optional
        Number of samples to generate.  Default is 50.
    endpoint : boolean, optional
        If true, `stop` is the last sample. Otherwise, it is not included.
        Default is True.
    base : array_like, optional
        The base of the log space. The step size between the elements in
        ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
        Default is 10.0.
    dtype : dtype
        The type of the output array.  If `dtype` is not given, the data type
        is inferred from `start` and `stop`. The inferred type will never be
        an integer; `float` is chosen even if the arguments would produce an
        array of integers.
    axis : int, optional
        The axis in the result to store the samples.  Relevant only if start
        or stop are array-like.  By default (0), the samples will be along a
        new axis inserted at the beginning. Use -1 to get an axis at the end.

        .. versionadded:: 1.16.0


    Returns
    -------
    samples : ndarray
        `num` samples, equally spaced on a log scale.

    See Also
    --------
    arange : Similar to linspace, with the step size specified instead of the
             number of samples. Note that, when used with a float endpoint, the
             endpoint may or may not be included.
    linspace : Similar to logspace, but with the samples uniformly distributed
               in linear space, instead of log space.
    geomspace : Similar to logspace, but with endpoints specified directly.
    :ref:`how-to-partition`

    Notes
    -----
    Logspace is equivalent to the code

    >>> y = np.linspace(start, stop, num=num, endpoint=endpoint)
    ... # doctest: +SKIP
    >>> power(base, y).astype(dtype)
    ... # doctest: +SKIP

    Examples
    --------
    >>> np.logspace(2.0, 3.0, num=4)
    array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
    >>> np.logspace(2.0, 3.0, num=4, endpoint=False)
    array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
    >>> np.logspace(2.0, 3.0, num=4, base=2.0)
    array([4.        ,  5.0396842 ,  6.34960421,  8.        ])

    Graphical illustration:

    >>> import matplotlib.pyplot as plt
    >>> N = 10
    >>> x1 = np.logspace(0.1, 1, N, endpoint=True)
    >>> x2 = np.logspace(0.1, 1, N, endpoint=False)
    >>> y = np.zeros(N)
    >>> plt.plot(x1, y, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.plot(x2, y + 0.5, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.ylim([-0.5, 1])
    (-0.5, 1)
    >>> plt.show()

    )r   r   r   NFr"   )r   r(   Úpowerr1   )r   r   r   r   r;   r   r   r6   s           r   r   r   ½   sY   € õz 	�˜ #°¸tÐDÑDÔD€AØ€}ÝŒy˜˜qÑ!Ô!Ð!ÝŒ9�T˜1ÑÔ×$Ò$ U°Ð$Ñ7Ô7Ð7r   c                 ó
   — | |fS r   r   )r   r   r   r   r   r   s         r   Ú_geomspace_dispatcherrA      r   r   c           	      ó  — t          | ¦  «        } t          |¦  «        }t          j        | dk    ¦  «        st          j        |dk    ¦  «        rt          d¦  «        ‚t	          | |t          |¦  «        t          j        d|¦  «        ¦  «        }|€|}nt          j        |¦  «        }|                      |d¬¦  «        } |                     |d¬¦  «        }t          j	        t          j
        | |¦  «        j        |¦  «        }t          j        |t          j        ¦  «        rP| j        dk    |j        dk    z  }t          j        |¦  «        r%| |         j        | |<   ||         j        ||<   d||<   t          j        | ¦  «        d	k    t          j        |¦  «        d	k    z  }	t          j        |	¦  «        rEt          j        | | |	¬
¦  «         t          j        |||	¬
¦  «         t          j        |||	¬
¦  «         t          j        | ¦  «        }
t          j        |¦  «        }t'          |
|||d|¬¦  «        }|dk    r| |d<   |dk    r|r||d	<   ||z  }|dk    rt          j        |d|¦  «        }|                     |d¬¦  «        S )a   
    Return numbers spaced evenly on a log scale (a geometric progression).

    This is similar to `logspace`, but with endpoints specified directly.
    Each output sample is a constant multiple of the previous.

    .. versionchanged:: 1.16.0
        Non-scalar `start` and `stop` are now supported.

    Parameters
    ----------
    start : array_like
        The starting value of the sequence.
    stop : array_like
        The final value of the sequence, unless `endpoint` is False.
        In that case, ``num + 1`` values are spaced over the
        interval in log-space, of which all but the last (a sequence of
        length `num`) are returned.
    num : integer, optional
        Number of samples to generate.  Default is 50.
    endpoint : boolean, optional
        If true, `stop` is the last sample. Otherwise, it is not included.
        Default is True.
    dtype : dtype
        The type of the output array.  If `dtype` is not given, the data type
        is inferred from `start` and `stop`. The inferred dtype will never be
        an integer; `float` is chosen even if the arguments would produce an
        array of integers.
    axis : int, optional
        The axis in the result to store the samples.  Relevant only if start
        or stop are array-like.  By default (0), the samples will be along a
        new axis inserted at the beginning. Use -1 to get an axis at the end.

        .. versionadded:: 1.16.0

    Returns
    -------
    samples : ndarray
        `num` samples, equally spaced on a log scale.

    See Also
    --------
    logspace : Similar to geomspace, but with endpoints specified using log
               and base.
    linspace : Similar to geomspace, but with arithmetic instead of geometric
               progression.
    arange : Similar to linspace, with the step size specified instead of the
             number of samples.
    :ref:`how-to-partition`

    Notes
    -----
    If the inputs or dtype are complex, the output will follow a logarithmic
    spiral in the complex plane.  (There are an infinite number of spirals
    passing through two points; the output will follow the shortest such path.)

    Examples
    --------
    >>> np.geomspace(1, 1000, num=4)
    array([    1.,    10.,   100.,  1000.])
    >>> np.geomspace(1, 1000, num=3, endpoint=False)
    array([   1.,   10.,  100.])
    >>> np.geomspace(1, 1000, num=4, endpoint=False)
    array([   1.        ,    5.62341325,   31.6227766 ,  177.827941  ])
    >>> np.geomspace(1, 256, num=9)
    array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])

    Note that the above may not produce exact integers:

    >>> np.geomspace(1, 256, num=9, dtype=int)
    array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
    >>> np.around(np.geomspace(1, 256, num=9)).astype(int)
    array([  1,   2,   4,   8,  16,  32,  64, 128, 256])

    Negative, decreasing, and complex inputs are allowed:

    >>> np.geomspace(1000, 1, num=4)
    array([1000.,  100.,   10.,    1.])
    >>> np.geomspace(-1000, -1, num=4)
    array([-1000.,  -100.,   -10.,    -1.])
    >>> np.geomspace(1j, 1000j, num=4)  # Straight line
    array([0.   +1.j, 0.  +10.j, 0. +100.j, 0.+1000.j])
    >>> np.geomspace(-1+0j, 1+0j, num=5)  # Circle
    array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
            6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
            1.00000000e+00+0.00000000e+00j])

    Graphical illustration of `endpoint` parameter:

    >>> import matplotlib.pyplot as plt
    >>> N = 10
    >>> y = np.zeros(N)
    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
    [<matplotlib.lines.Line2D object at 0x...>]
    >>> plt.axis([0.5, 2000, 0, 3])
    [0.5, 2000, 0, 3]
    >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
    >>> plt.show()

    r   z&Geometric sequence cannot include zeror   NTr"   g        y              ð?r    )r!   Úwherer=   )r   r   r;   r   r   F)r   r(   r.   r&   r   r'   Úzerosr   r1   ÚonesÚ	broadcastÚshaper)   ÚcomplexfloatingÚrealÚimagÚsignÚnegativeÚlog10r   r/   )r   r   r   r   r   r   r3   Úout_signÚall_imagÚboth_negativeÚ	log_startÚlog_stopÚresults                r   r   r   %  sw  € õP �uÑÔ€EÝ�dÑÔ€DÝ
„wˆu˜ŠzÑÔð C�cœg d¨a¢iÑ0Ô0ð CÝÐAÑBÔBÐBå	�U˜D¥%¨¡*¤*­c¬i¸¸EÑ.BÔ.BÑ	CÔ	C€BØ€}Øˆˆõ ”	˜%Ñ Ô ˆð
 �LŠL˜ $ˆLÑ'Ô'€EØ�;Š;�r ˆ;Ñ%Ô%€DåŒx�œ e¨TÑ2Ô2Ô8¸"Ñ=Ô=€Hõ „~�b�#Ô-Ñ.Ô.ð $Ø”J "Ò$¨¬°bªÑ9ˆÝŒ7�8ÑÔð 	$Ø# HœoÔ2ˆE�(‰OØ! (œ^Ô0ˆD�‰NØ!#ˆH�XÑå”X˜e‘_”_¨Ò*­s¬x¸©~¬~ÀÒ/CÑD€MÝ
„wˆ}ÑÔð BÝŒ�U ¨]Ð;Ñ;Ô;Ð;ÝŒ�T˜t¨=Ð9Ñ9Ô9Ð9ÝŒ�X 8°=ÐAÑAÔAÐAå”	˜%Ñ Ô €IÝŒy˜‰Œ€HÝ�i ¨sØ'¨d¸%ðAñ Aô A€Fð
 ˆQ‚w€wØˆˆq‰	Ø�Š7ˆ7�xˆ7ØˆF�2‰Jà˜Ñ€Fàˆq‚y€yÝ”˜f a¨Ñ.Ô.ˆà�=Š=˜ Uˆ=Ñ+Ô+Ð+r   c                 ó¨   — d}t          | t          j        t          j        t          f¦  «        rdS t          | t
          ¦  «        r| j        |z  rdS dS )z¬
    Returns true if the only way to set the docstring of `obj` from python is
    via add_docstring.

    This function errs on the side of being overly conservative.
    i   FT)Ú
isinstanceÚtypesÚFunctionTypeÚ
MethodTypeÚpropertyÚtypeÚ	__flags__)ÚobjÚPy_TPFLAGS_HEAPTYPEs     r   Ú_needs_add_docstringr^   Ã  sY   € ð !Ðå�#�Ô*­EÔ,<½hÐGÑHÔHð Øˆuå�#•tÑÔð  ¤Ð1DÑ!Dð Øˆuàˆ4r   c                 óÊ   — |r>t          | ¦  «        s/t          j        d                     | ¦  «        t          d¬¦  «         	 t          | |¦  «         d S # t          $ r Y d S w xY w)Nz[add_newdoc was used on a pure-python object {}. Prefer to attach it directly to the source.é   )Ú
stacklevel)r^   ÚwarningsÚwarnÚformatÚUserWarningr	   Ú	Exception)r\   ÚdocÚwarn_on_pythons      r   Ú_add_docstringri   Õ  s†   € Øð Õ2°3Ñ7Ô7ð ÝŒð:çŠV�C‰[Œ[ÝØð	ñ 	ô 	ð 	ðÝ�c˜3ÑÔÐÐÐøÝð ð ð Øˆˆðøøøs   ÁA Á
A"Á!A"c                 ó  — t          t          | t          ¦   «         i |g¦  «        |¦  «        }t          |t          ¦  «        r%t          ||                     ¦   «         |¦  «         dS t          |t          ¦  «        r8|\  }}t          t          ||¦  «        |                     ¦   «         |¦  «         dS t          |t          ¦  «        r9|D ]8\  }}t          t          ||¦  «        |                     ¦   «         |¦  «         Œ7dS dS )a  
    Add documentation to an existing object, typically one defined in C

    The purpose is to allow easier editing of the docstrings without requiring
    a re-compile. This exists primarily for internal use within numpy itself.

    Parameters
    ----------
    place : str
        The absolute name of the module to import from
    obj : str
        The name of the object to add documentation to, typically a class or
        function name
    doc : {str, Tuple[str, str], List[Tuple[str, str]]}
        If a string, the documentation to apply to `obj`

        If a tuple, then the first element is interpreted as an attribute of
        `obj` and the second as the docstring to apply - ``(method, docstring)``

        If a list, then each element of the list should be a tuple of length
        two - ``[(method1, docstring1), (method2, docstring2), ...]``
    warn_on_python : bool
        If True, the default, emit `UserWarning` if this is used to attach
        documentation to a pure-python object.

    Notes
    -----
    This routine never raises an error if the docstring can't be written, but
    will raise an error if the object being documented does not exist.

    This routine cannot modify read-only docstrings, as appear
    in new-style classes or built-in functions. Because this
    routine never raises an error the caller must check manually
    that the docstrings were changed.

    Since this function grabs the ``char *`` from a c-level str object and puts
    it into the ``tp_doc`` slot of the type of `obj`, it violates a number of
    C-API best-practices, by:

    - modifying a `PyTypeObject` after calling `PyType_Ready`
    - calling `Py_INCREF` on the str and losing the reference, so the str
      will never be released

    If possible it should be avoided.
    N)	ÚgetattrÚ
__import__ÚglobalsrU   Ústrri   ÚstripÚtupleÚlist)Úplacer\   rg   rh   ÚnewÚattrÚ	docstrings          r   Ú
add_newdocrv   ã  s  € õ\ •*˜U¥G¡I¤I¨r°C°5Ñ9Ô9¸3Ñ
?Ô
?€CÝ�#•sÑÔð RÝ�s˜CŸIšI™KœK¨Ñ8Ô8Ð8Ð8Ð8Ý	�C�Ñ	Ô	ð RØ‰ˆˆiÝ•w˜s DÑ)Ô)¨9¯?ª?Ñ+<Ô+<¸nÑMÔMÐMÐMÐMÝ	�C�Ñ	Ô	ð RØ"ð 	Rð 	R‰OˆD�)Ý�7 3¨Ñ-Ô-¨y¯ªÑ/@Ô/@À.ÑQÔQÐQÐQðRð Rð	Rð 	Rr   )NNNNN)r   TFNr   )r   Tr=   Nr   )NNNN)r   TNr   )T)Ú	functoolsrb   r$   rV   Ú r   r(   r   r   r   r   Únumpy.core.multiarrayr	   Ú
numpy.corer
   Ú__all__ÚpartialÚarray_function_dispatchr   r   r<   r   rA   r   r^   ri   rv   r   r   r   ú<module>r~      só  ðØ Ð Ð Ð Ø €€€Ø €€€Ø €€€à Ð Ð Ð Ð Ð Ø 7Ð 7Ð 7Ð 7Ð 7Ð 7Ð 7Ð 7Ð 7Ð 7Ð 7Ð 7Ø /Ð /Ð /Ð /Ð /Ð /Ø  Ð  Ð  Ð  Ð  Ð  à
/Ð
/Ð
/€ð ,˜)Ô+ØÔ%¨gð7ñ 7ô 7Ð ð HLØ*.ðð ð ð ð
 ÐÐ-Ñ.Ô.ØFJØð]+ð ]+ð ]+ñ /Ô.ð]+ð@ EIØ*.ðð ð ð ð
 ÐÐ-Ñ.Ô.ØBFØð_8ð _8ð _8ñ /Ô.ð_8ðD GKØ#ðð ð ð ð
 ÐÐ.Ñ/Ô/ðZ,ð Z,ð Z,ñ 0Ô/ðZ,ðzð ð ð$ð ð ð6Rð 6Rð 6Rð 6Rð 6Rð 6Rr   