
    !Цi"                     l    S r SSKrSS/rSS jrSS jrSS jrSS jrSS	 jr\\\\\\S
.r	SS jr
S rg)z[
The thresholding helper module implements the most popular signal thresholding
functions.
    N	thresholdthreshold_firmc                 X   [         R                  " U 5      n [         R                  " U 5      n[         R                  " SS9   SX-  -
  nUR	                  SS US9  X-  nS S S 5        US:X  a  W$ [         R
                  " X15      n[         R                  " XRW5      $ ! , (       d  f       NC= f)Nignoredivide   r   minmaxoutnpasarrayabsoluteerrstatecliplesswheredatavalue
substitute	magnitudethresholdedconds         Q/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/pywt/_thresholding.pysoftr      s    ::dDD!I	H	%5?*QDk:(	 
& Qwwy(xx+66 
&	%s   B
B)c                 f   [         R                  " U 5      n [         R                  " U 5      n[         R                  " SS9   SUS-  US-  -  -
  nUR	                  SSUS9  X-  nSSS5        US:X  a  W$ [         R
                  " X15      n[         R                  " XRW5      $ ! , (       d  f       NC= f)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wwy(xx+66 
&	%s   $B""
B0c                     [         R                  " U 5      n [         R                  " [         R                  " U 5      U5      n[         R                  " X2U 5      $ )N)r   r   r   r   r   )r   r   r   r   s       r   hardr#   3   s:    ::dD772;;t$e,D88Dd++    c                     [         R                  " U 5      n [         R                  " U 5      (       a  [        S5      e[         R                  " [         R
                  " X5      X 5      $ )Nz,greater thresholding only supports real data)r   r   iscomplexobj
ValueErrorr   r   r   r   r   s      r   greaterr)   9   sE    ::dD	tGHH88BGGD(*;;r$   c                     [         R                  " U 5      n [         R                  " U 5      (       a  [        S5      e[         R                  " [         R
                  " X5      X 5      $ )Nz)less thresholding only supports real data)r   r   r&   r'   r   r)   r(   s      r   r   r   @   sE    ::dD	tDEE88BJJt+Z>>r$   )r   r#   r)   r   garrotegarottec                      [         U   " XU5      $ ! [         aN    S [        [         R                  5       5       5       n[	        SR                  SR                  U5      5      5      ef = f)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   .   #    U  H  nS U S 3v   M     g7f)'N ).0keys     r   	<genexpr>threshold.<locals>.<genexpr>   s      53  #!C5
3s   z.The mode parameter only takes values from: {}.z, )thresholding_optionsKeyErrorsortedkeysr'   formatjoin)r   r   moder   r8   s        r   r   r   Q   si    d3#D)$zBB 35+00235I &413 	3	3s
    AA*c                    US:  a  [        S5      eX!:  a  [        S5      e[        R                  " U 5      n [        R                  " U 5      n[        R                  " SS9   X!-
  nUSX-  -
  -  U-  nUR                  SSUS9  X-  nSSS5        [        R                  " X2:  5      n[        R                  " US   5      (       a  X   WU'   W$ ! , (       d  f       NM= f)	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      s    p 1}:;;DF 	F ::dDD!I	H	%& A	(;$;<uDQDk:( 
& )01J	vvjm"&"2J 
&	%s   "'C
C)r   )r   r   )__doc__numpyr   __all__r   r!   r#   r)   r   r5   r   r   r0   r$   r   <module>rE      s\   
 (
)7"7$,<? !% $#* $#-#- Y3xLr$   