
     eY"                     v    d Z ddlmZmZmZ ddlZddgZddZddZ	ddZ
dd	Zdd
Zee
eee	e	dZddZd ZdS )z[
The thresholding helper module implements the most popular signal thresholding
functions.
    )divisionprint_functionabsolute_importN	thresholdthreshold_firmc                 \   t          j        |           } t          j        |           }t          j        d          5  d||z  z
  }|                    dd |           | |z  }d d d            n# 1 swxY w Y   |dk    r|S t          j        ||          }t          j        |||          S )Nignoredivide   r   minmaxoutnpasarrayabsoluteerrstatecliplesswheredatavalue
substitute	magnitudethresholdedconds         2lib/python3.11/site-packages/pywt/_thresholding.pysoftr!      s    :dDD!!I	H	%	%	% ) )5?*QDk:::[(	) ) ) ) ) ) ) ) ) ) ) ) ) ) ) Qwy%((xj+666s   &A00A47A4c                 h   t          j        |           } t          j        |           }t          j        d          5  d|dz  |dz  z  z
  }|                    dd|           | |z  }ddd           n# 1 swxY w Y   |dk    r|S t          j        ||          }t          j        |||          S )zNon-negative Garrote.r	   r
   r      r   Nr   r   r   s         r    
nn_garroter$   "   s    :dDD!!I	H	%	%	% ) )5!8IqL00QDk:::[(	) ) ) ) ) ) ) ) ) ) ) ) ) ) ) Qwy%((xj+666s   ,A66A:=A:c                     t          j        |           } t          j        t          j        |           |          }t          j        |||           S )N)r   r   r   r   r   )r   r   r   r   s       r    hardr&   4   s@    :dD72;t$$e,,D8D*d+++    c                     t          j        |           } t          j        |           rt          d          t          j        t          j        | |          ||           S )Nz,greater thresholding only supports real data)r   r   iscomplexobj
ValueErrorr   r   r   r   r   s      r    greaterr,   :   sS    :dD	t IGHHH8BGD%((*d;;;r'   c                     t          j        |           } t          j        |           rt          d          t          j        t          j        | |          ||           S )Nz)less thresholding only supports real data)r   r   r)   r*   r   r,   r+   s      r    r   r   A   sS    :dD	t FDEEE8BJtU++Z>>>r'   )r!   r&   r,   r   garrotegarotter!   c                    	 t          |         | ||          S # t          $ rf d t          t                                                     D             }t	          d                    d                    |                              w xY w)a  
    Thresholds the input data depending on the mode argument.

    In ``soft`` thresholding [1]_, data values with absolute value less than
    `param` are replaced with `substitute`. Data values with absolute value
    greater or equal to the thresholding value are shrunk toward zero
    by `value`.  In other words, the new value is
    ``data/np.abs(data) * np.maximum(np.abs(data) - value, 0)``.

    In ``hard`` thresholding, the data values where their absolute value is
    less than the value param are replaced with `substitute`. Data values with
    absolute value greater or equal to the thresholding value stay untouched.

    ``garrote`` corresponds to the Non-negative garrote threshold [2]_, [3]_.
    It is intermediate between ``hard`` and ``soft`` thresholding.  It behaves
    like soft thresholding for small data values and approaches hard
    thresholding for large data values.

    In ``greater`` thresholding, the data is replaced with `substitute` where
    data is below the thresholding value. Greater data values pass untouched.

    In ``less`` thresholding, the data is replaced with `substitute` where data
    is above the thresholding value. Lesser data values pass untouched.

    Both ``hard`` and ``soft`` thresholding also support complex-valued data.

    Parameters
    ----------
    data : array_like
        Numeric data.
    value : scalar
        Thresholding value.
    mode : {'soft', 'hard', 'garrote', 'greater', 'less'}
        Decides the type of thresholding to be applied on input data. Default
        is 'soft'.
    substitute : float, optional
        Substitute value (default: 0).

    Returns
    -------
    output : array
        Thresholded array.

    See Also
    --------
    threshold_firm

    References
    ----------
    .. [1] D.L. Donoho and I.M. Johnstone. Ideal Spatial Adaptation via
        Wavelet Shrinkage. Biometrika. Vol. 81, No. 3, pp.425-455, 1994.
        DOI:10.1093/biomet/81.3.425
    .. [2] L. Breiman. Better Subset Regression Using the Nonnegative Garrote.
        Technometrics, Vol. 37, pp. 373-384, 1995.
        DOI:10.2307/1269730
    .. [3] H-Y. Gao.  Wavelet Shrinkage Denoising Using the Non-Negative
        Garrote.  Journal of Computational and Graphical Statistics Vol. 7,
        No. 4, pp.469-488. 1998.
        DOI:10.1080/10618600.1998.10474789

    Examples
    --------
    >>> import numpy as np
    >>> import pywt
    >>> data = np.linspace(1, 4, 7)
    >>> data
    array([ 1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ])
    >>> pywt.threshold(data, 2, 'soft')
    array([ 0. ,  0. ,  0. ,  0.5,  1. ,  1.5,  2. ])
    >>> pywt.threshold(data, 2, 'hard')
    array([ 0. ,  0. ,  2. ,  2.5,  3. ,  3.5,  4. ])
    >>> pywt.threshold(data, 2, 'garrote')
    array([ 0.        ,  0.        ,  0.        ,  0.9       ,  1.66666667,
            2.35714286,  3.        ])
    >>> pywt.threshold(data, 2, 'greater')
    array([ 0. ,  0. ,  2. ,  2.5,  3. ,  3.5,  4. ])
    >>> pywt.threshold(data, 2, 'less')
    array([ 1. ,  1.5,  2. ,  0. ,  0. ,  0. ,  0. ])

    c              3   @   K   | ]}d                      |          V  dS )z'{0}'N)format).0keys     r    	<genexpr>zthreshold.<locals>.<genexpr>   s>       5 5s## 5 5 5 5 5 5r'   z/The mode parameter only takes values from: {0}.z, )thresholding_optionsKeyErrorsortedkeysr*   r2   join)r   r   moder   r9   s        r    r   r   R   s    d3#D)$zBBB 3 3 35 5+0022335 5 5J &4113 3 	3	3s
    A0B	c                    |dk     rt          d          ||k     rt          d          t          j        |           } t          j        |           }t          j        d          5  ||z
  }|d||z  z
  z  |z  }|                    dd|           | |z  }ddd           n# 1 swxY w Y   t          j        ||k              }t          j        |d                   r| |         ||<   |S )	a_  Firm threshold.

    The approach is intermediate between soft and hard thresholding [1]_. It
    behaves the same as soft-thresholding for values below `value_low` and
    the same as hard-thresholding for values above `thresh_high`.  For
    intermediate values, the thresholded value is in between that corresponding
    to soft or hard thresholding.

    Parameters
    ----------
    data : array-like
        The data to threshold.  This can be either real or complex-valued.
    value_low : float
        Any values smaller then `value_low` will be set to zero.
    value_high : float
        Any values larger than `value_high` will not be modified.

    Notes
    -----
    This thresholding technique is also known as semi-soft thresholding [2]_.

    For each value, `x`, in `data`. This function computes::

        if np.abs(x) <= value_low:
            return 0
        elif np.abs(x) > value_high:
            return x
        elif value_low < np.abs(x) and np.abs(x) <= value_high:
            return x * value_high * (1 - value_low/x)/(value_high - value_low)

    ``firm`` is a continuous function (like soft thresholding), but is
    unbiased for large values (like hard thresholding).

    If ``value_high == value_low`` this function becomes hard-thresholding.
    If ``value_high`` is infinity, this function becomes soft-thresholding.

    Returns
    -------
    val_new : array-like
        The values after firm thresholding at the specified thresholds.

    See Also
    --------
    threshold

    References
    ----------
    .. [1] H.-Y. Gao and A.G. Bruce. Waveshrink with firm shrinkage.
        Statistica Sinica, Vol. 7, pp. 855-874, 1997.
    .. [2] A. Bruce and H-Y. Gao. WaveShrink: Shrinkage Functions and
        Thresholds. Proc. SPIE 2569, Wavelet Applications in Signal and
        Image Processing III, 1995.
        DOI:10.1117/12.217582
    r   zvalue_low must be non-negative.z6value_high must be greater than or equal to value_low.r	   r
   r   Nr   )r*   r   r   r   r   r   r   any)r   	value_low
value_highr   vdiffr   
large_valss          r    r   r      sQ   p 1}}:;;;IDF F 	F :dDD!!I	H	%	%	% ) )Y& A	)(;$;<uDQDk:::[() ) ) ) ) ) ) ) ) ) ) ) ) ) ) )j011J	vjm 3"&z"2Js   (1B%%B),B))r   )r!   r   )__doc__
__future__r   r   r   numpyr   __all__r!   r$   r&   r,   r   r6   r   r    r'   r    <module>rG      s   
 A @ @ @ @ @ @ @ @ @    (
)7 7 7 7"7 7 7 7$, , , ,< < < <? ? ? ? !% $#* $#-#-  Y3 Y3 Y3 Y3xL L L L Lr'   