
    (ph=                        S r SSKrSSKrSSKJr  SSKJrJr  SSK	J
r
Jr  SS/r\" S	 S
 SS SSS9   S$S\R                  R                  S\R                  R                  S-  S\S-  S\S\R"                  \R$                  -  4
S jj5       rS%S jr\" S SS \S9SSSSS.S\R                  R                  S\S-  S\S-  S\S\S\R"                  \R$                  -  4S jj5       rS rS  rS! rS" rS# rg)&z5
Created on Fri Apr  2 09:06:05 2021

@author: matth
    N)special   )_axis_nan_policy_factory_broadcast_arrays)array_namespacexp_moveaxis_to_endentropydifferential_entropyc                     U $ N xs    G/var/www/html/venv/lib/python3.13/site-packages/scipy/stats/_entropy.py<lambda>r          a    c                 "    SU ;   a  U S   b  S$ S$ )Nqk   r   r   )kwgss    r   r   r      s!    dltDz5 		r   c                     U 4$ r   r   r   s    r   r   r      s    A4r   T)	n_samples	n_outputsresult_to_tuplepaired	too_smallpkr   baseaxisreturnc                 D   Ub  US::  a  [        S5      eUc  [        U 5      O
[        X5      nUR                  U 5      n [        R                  " SS9   SU -  UR                  XSS9-  n SSS5        Uc  [        R                  " U 5      nOXUR                  U5      n[        X4SUS	9u  p[        USS9nSU-  UR
                  " U40 UD6-  n[        R                  " X5      nUR                  XSS
9nUb  U[        R                  " U5      -  nU$ ! , (       d  f       N= f)a  
Calculate the Shannon entropy/relative entropy of given distribution(s).

If only probabilities `pk` are given, the Shannon entropy is calculated as
``H = -sum(pk * log(pk))``.

If `qk` is not None, then compute the relative entropy
``D = sum(pk * log(pk / qk))``. This quantity is also known
as the Kullback-Leibler divergence.

This routine will normalize `pk` and `qk` if they don't sum to 1.

Parameters
----------
pk : array_like
    Defines the (discrete) distribution. Along each axis-slice of ``pk``,
    element ``i`` is the  (possibly unnormalized) probability of event
    ``i``.
qk : array_like, optional
    Sequence against which the relative entropy is computed. Should be in
    the same format as `pk`.
base : float, optional
    The logarithmic base to use, defaults to ``e`` (natural logarithm).
axis : int, optional
    The axis along which the entropy is calculated. Default is 0.

Returns
-------
S : {float, array_like}
    The calculated entropy.

Notes
-----
Informally, the Shannon entropy quantifies the expected uncertainty
inherent in the possible outcomes of a discrete random variable.
For example,
if messages consisting of sequences of symbols from a set are to be
encoded and transmitted over a noiseless channel, then the Shannon entropy
``H(pk)`` gives a tight lower bound for the average number of units of
information needed per symbol if the symbols occur with frequencies
governed by the discrete distribution `pk` [1]_. The choice of base
determines the choice of units; e.g., ``e`` for nats, ``2`` for bits, etc.

The relative entropy, ``D(pk|qk)``, quantifies the increase in the average
number of units of information needed per symbol if the encoding is
optimized for the probability distribution `qk` instead of the true
distribution `pk`. Informally, the relative entropy quantifies the expected
excess in surprise experienced if one believes the true distribution is
`qk` when it is actually `pk`.

A related quantity, the cross entropy ``CE(pk, qk)``, satisfies the
equation ``CE(pk, qk) = H(pk) + D(pk|qk)`` and can also be calculated with
the formula ``CE = -sum(pk * log(qk))``. It gives the average
number of units of information needed per symbol if an encoding is
optimized for the probability distribution `qk` when the true distribution
is `pk`. It is not computed directly by `entropy`, but it can be computed
using two calls to the function (see Examples).

See [2]_ for more information.

References
----------
.. [1] Shannon, C.E. (1948), A Mathematical Theory of Communication.
       Bell System Technical Journal, 27: 379-423.
       https://doi.org/10.1002/j.1538-7305.1948.tb01338.x
.. [2] Thomas M. Cover and Joy A. Thomas. 2006. Elements of Information
       Theory (Wiley Series in Telecommunications and Signal Processing).
       Wiley-Interscience, USA.


Examples
--------
The outcome of a fair coin is the most uncertain:

>>> import numpy as np
>>> from scipy.stats import entropy
>>> base = 2  # work in units of bits
>>> pk = np.array([1/2, 1/2])  # fair coin
>>> H = entropy(pk, base=base)
>>> H
1.0
>>> H == -np.sum(pk * np.log(pk)) / np.log(base)
True

The outcome of a biased coin is less uncertain:

>>> qk = np.array([9/10, 1/10])  # biased coin
>>> entropy(qk, base=base)
0.46899559358928117

The relative entropy between the fair coin and biased coin is calculated
as:

>>> D = entropy(pk, qk, base=base)
>>> D
0.7369655941662062
>>> np.isclose(D, np.sum(pk * np.log(pk/qk)) / np.log(base), rtol=4e-16, atol=0)
True

The cross entropy can be calculated as the sum of the entropy and
relative entropy`:

>>> CE = entropy(pk, base=base) + entropy(pk, qk, base=base)
>>> CE
1.736965594166206
>>> CE == -np.sum(pk * np.log(qk)) / np.log(base)
True

Nr   +`base` must be a positive number or `None`.ignore)invalid      ?Tr!   keepdims)r!   xpr!   )
ValueErrorr   asarraynperrstatesumr   entrr   dictrel_entrmathlog)r   r   r    r!   r*   vec
sum_kwargsSs           r   r	   r	      s   v DAIFGG "
	0GB	BB	X	&VbffRTf:: 
'	zll2ZZ^"B8$2>td3
VbffR.:..r&
sA	TXXd^H 
'	&s   D
Dc                     U S   nUR                   U   nUR                  S[        R                  " [        R                  " U5      S-   5      5      nSSU-  s=::  a  U:  d   g  gg)Nr   window_length      ?r   TF)shapegetr4   floorsqrt)sampleskwargsr!   valuesnr:   s         r   "_differential_entropy_is_too_smallrD      sb    QZFTAJJ#zz$))A,*<=?MM!%A% &r   c                     U $ r   r   r   s    r   r   r      r   r   c                     U 4$ r   r   r   s    r   r   r      s    r   )r   r   r   auto)r:   r    r!   methodrB   r:   rH   c                :   [        U 5      nUR                  U 5      n UR                  U R                  S5      (       a*  UR	                  XR                  S5      R                  5      n [        XUS9n U R                  S   nUc-  [        R                  " [        R                  " U5      S-   5      nSSU-  s=::  a  U:  d  O  [        SU SU S	35      eUb  US
::  a  [        S5      eUR                  U SS9n[        [        [        [        [        S.nUR!                  5       nXH;  a  S[#        U5       3n	[        U	5      eUS:X  a  US::  a  SnOUS::  a  SnOSnX   " XqUS9n
Ub  U
[        R$                  " U5      -  n
UR	                  XR                  5      $ )a  Given a sample of a distribution, estimate the differential entropy.

Several estimation methods are available using the `method` parameter. By
default, a method is selected based the size of the sample.

Parameters
----------
values : sequence
    Sample from a continuous distribution.
window_length : int, optional
    Window length for computing Vasicek estimate. Must be an integer
    between 1 and half of the sample size. If ``None`` (the default), it
    uses the heuristic value

    .. math::
        \left \lfloor \sqrt{n} + 0.5 \right \rfloor

    where :math:`n` is the sample size. This heuristic was originally
    proposed in [2]_ and has become common in the literature.
base : float, optional
    The logarithmic base to use, defaults to ``e`` (natural logarithm).
axis : int, optional
    The axis along which the differential entropy is calculated.
    Default is 0.
method : {'vasicek', 'van es', 'ebrahimi', 'correa', 'auto'}, optional
    The method used to estimate the differential entropy from the sample.
    Default is ``'auto'``.  See Notes for more information.

Returns
-------
entropy : float
    The calculated differential entropy.

Notes
-----
This function will converge to the true differential entropy in the limit

.. math::
    n \to \infty, \quad m \to \infty, \quad \frac{m}{n} \to 0

The optimal choice of ``window_length`` for a given sample size depends on
the (unknown) distribution. Typically, the smoother the density of the
distribution, the larger the optimal value of ``window_length`` [1]_.

The following options are available for the `method` parameter.

* ``'vasicek'`` uses the estimator presented in [1]_. This is
  one of the first and most influential estimators of differential entropy.
* ``'van es'`` uses the bias-corrected estimator presented in [3]_, which
  is not only consistent but, under some conditions, asymptotically normal.
* ``'ebrahimi'`` uses an estimator presented in [4]_, which was shown
  in simulation to have smaller bias and mean squared error than
  the Vasicek estimator.
* ``'correa'`` uses the estimator presented in [5]_ based on local linear
  regression. In a simulation study, it had consistently smaller mean
  square error than the Vasiceck estimator, but it is more expensive to
  compute.
* ``'auto'`` selects the method automatically (default). Currently,
  this selects ``'van es'`` for very small samples (<10), ``'ebrahimi'``
  for moderate sample sizes (11-1000), and ``'vasicek'`` for larger
  samples, but this behavior is subject to change in future versions.

All estimators are implemented as described in [6]_.

References
----------
.. [1] Vasicek, O. (1976). A test for normality based on sample entropy.
       Journal of the Royal Statistical Society:
       Series B (Methodological), 38(1), 54-59.
.. [2] Crzcgorzewski, P., & Wirczorkowski, R. (1999). Entropy-based
       goodness-of-fit test for exponentiality. Communications in
       Statistics-Theory and Methods, 28(5), 1183-1202.
.. [3] Van Es, B. (1992). Estimating functionals related to a density by a
       class of statistics based on spacings. Scandinavian Journal of
       Statistics, 61-72.
.. [4] Ebrahimi, N., Pflughoeft, K., & Soofi, E. S. (1994). Two measures
       of sample entropy. Statistics & Probability Letters, 20(3), 225-234.
.. [5] Correa, J. C. (1995). A new estimator of entropy. Communications
       in Statistics-Theory and Methods, 24(10), 2439-2449.
.. [6] Noughabi, H. A. (2015). Entropy Estimation Using Numerical Methods.
       Annals of Data Science, 2(2), 231-241.
       https://link.springer.com/article/10.1007/s40745-015-0045-9

Examples
--------
>>> import numpy as np
>>> from scipy.stats import differential_entropy, norm

Entropy of a standard normal distribution:

>>> rng = np.random.default_rng()
>>> values = rng.standard_normal(100)
>>> differential_entropy(values)
1.3407817436640392

Compare with the true entropy:

>>> float(norm.entropy())
1.4189385332046727

For several sample sizes between 5 and 1000, compare the accuracy of
the ``'vasicek'``, ``'van es'``, and ``'ebrahimi'`` methods. Specifically,
compare the root mean squared error (over 1000 trials) between the estimate
and the true differential entropy of the distribution.

>>> from scipy import stats
>>> import matplotlib.pyplot as plt
>>>
>>>
>>> def rmse(res, expected):
...     '''Root mean squared error'''
...     return np.sqrt(np.mean((res - expected)**2))
>>>
>>>
>>> a, b = np.log10(5), np.log10(1000)
>>> ns = np.round(np.logspace(a, b, 10)).astype(int)
>>> reps = 1000  # number of repetitions for each sample size
>>> expected = stats.expon.entropy()
>>>
>>> method_errors = {'vasicek': [], 'van es': [], 'ebrahimi': []}
>>> for method in method_errors:
...     for n in ns:
...        rvs = stats.expon.rvs(size=(reps, n), random_state=rng)
...        res = stats.differential_entropy(rvs, method=method, axis=-1)
...        error = rmse(res, expected)
...        method_errors[method].append(error)
>>>
>>> for method, errors in method_errors.items():
...     plt.loglog(ns, errors, label=method)
>>>
>>> plt.legend()
>>> plt.xlabel('sample size')
>>> plt.ylabel('RMSE (1000 trials)')
>>> plt.title('Entropy Estimator Error (Exponential Distribution)')

integralr'   r*   r   r;   r   zWindow length (z7) must be positive and less than half the sample size (z).r   r$   r+   )vasicekvan escorreaebrahimirG   z`method` must be one of rG   
   rM   i  rO   rL   )r   r-   isdtypedtypeastyper   r<   r4   r>   r?   r,   sort_vasicek_entropy_van_es_entropy_correa_entropy_ebrahimi_entropylowersetr5   )rB   r:   r    r!   rH   r*   rC   sorted_datamethodsmessageress              r   r
   r
      s   h 
	 BZZF	zz&,,
++6::b>#7#784FRA

499Q<##56M!%A%m_ -**+B0
 	

 DAIFGG''&r'*K*((,'	)G
 \\^F,S\N;!!7F$YFF
/+
<Ctxx~ 99S,,''r   c                    U R                   SS U4-   nUR                  U SSS24   U5      nUR                  U SSS24   U5      nUR                  X@U4SS9$ )z9Pad the data for computing the rolling window difference.Nr   .r   r+   )r<   broadcast_toconcat)Xmr*   r<   XlXrs         r   _pad_along_last_axisrf   p  sg     GGCRLA4E	37U	+B	38e	,B99bR[r9**r   c                    U R                   S   n[        XUS9n U SSU-  S24   U SSSU-  24   -
  nUR                  USU-  -  U-  5      nUR                  USS9$ )z:Compute the Vasicek estimator as described in [6] Eq. 1.3.r   rK   .r   Nr+   )r<   rf   r5   mean)rb   rc   r*   rC   differenceslogss         r   rU   rU   y  sr    	AQb)ACQK.1S)BF)^#44K66!QqS'K'(D774b7!!r   c                p   U R                   S   nU SUS24   U SSU* 24   -
  nSX1-
  -  UR                  UR                  US-   U-  U-  5      SS9-  nUR                  XS-   UR                  S9nXRR                  SU-  5      -   [
        R                  " U5      -   [
        R                  " US-   5      -
  $ )z1Compute the van Es estimator as described in [6].r   .Nr   r+   rR   )r<   r0   r5   arangerR   r4   )rb   rc   r*   rC   
differenceterm1ks          r   rV   rV     s     	
A37aSqbSk)JqsGbffRVVQqS!Gj$89fCCE
		!qS	,A66!A#;!,txx!}<<r   c                   U R                   S   n[        XUS9n U SSU-  S24   U SSSU-  24   -
  nUR                  SUS-   U R                  S9nUR	                  U5      S-  nSXUU:*     S-
  U-  -   XeU:*  '   SX5XSU-
  S-   :     -
  U-  -   XeX1-
  S-   :  '   UR                  X4-  Xa-  -  5      nUR                  USS	9$ )
z3Compute the Ebrahimi estimator as described in [6].r   rK   .r   Nrh   r   rm   r+   )r<   rf   rn   rR   	ones_liker5   ri   )rb   rc   r*   rC   rj   icirk   s           r   rX   rX     s     	
AQb)ACQK.1S)BF)^#44K
		!QqS	(A	a	BaQi!mQ&&BAvJaA1QJ-/22BAEAI~66!/RV,-D774b7!!r   c                   U R                   S   n[        XUS9n UR                  SUS-   5      nUR                  U* US-   5      SS2S4   nXE-   nXa-   S-
  nUR                  U SU4   SSS9nU SU4   U-
  n	UR	                  X-  SS	9n
X2R	                  U	S
-  SS	9-  nUR                  UR                  X-  5      SS	9* $ )z1Compute the Correa estimator as described in [6].r   rK   r   N.rh   Tr(   r+   r   )r<   rf   rn   ri   r0   r5   )rb   rc   r*   rC   rt   djjj0Xibarro   numdens               r   rW   rW     s     	
AQb)A
		!QqSA	A2qs	AtG	$B	A	
BGGAc2gJR$G7E37e#J
&&R&
(C
FF:q=rF*
*CGGBFF37O"G---r   )NNr   )r   )__doc__r4   numpyr.   scipyr   _axis_nan_policyr   r   scipy._lib._array_apir   r   __all__typing	ArrayLikefloatintnumberndarrayr	   rD   strr
   rf   rU   rV   rX   rW   r   r   r   <module>r      sl      I E,
-   .2!%E		## E		##d*E$,E E RZZ'	EEP 1n0 !%~(II~( :~( $,	~(
 ~( ~( YY~(	~(B+"="".r   