
    HR-e              
          d dl Z d dlmZ d dlZd dlZd dlmZmZm	Z	 d dl
mZ d dlmZmZ d dlmZ dZ e e j        ee                    Zg dZd	Zd
dgZd
dgZ	 dZ e e j        eedd                    ZdZ e e j        eedd                    Zd!dZd"dZd Z  G d d          Z! G d d          Z"ej#        $                    de          d             Z%ej#        $                    d e j        eeeee                    d             Z&ej#        $                    d e j        eeeee                    d             Z'ej#        $                    ddd
idd
idd
ig          d             Z(d  Z)dS )#    N)nullcontext)assert_allcloseassert_array_almost_equal_nulpassert_array_equal)units)convolveconvolve_fft)AstropyUserWarning)z>f4z<f4>f8z<f8)Nfillwrap)interpolater   TFboundarynan_treatmentnormalize_kerneldealiasTFr   r   r   preserve_nanc                 ^    | t          j        t          d          }nt                      }|S )NzWThe convolve_fft version of boundary=None is equivalent to the convolve boundary='fill'match)pytestwarnsr
   r   )r   ctxs     Klib/python3.11/site-packages/astropy/convolution/tests/test_convolve_fft.pyexpected_boundary_warningr   9   s;     l@
 
 
 mmJ    c                 f    |r | dk    rt          j        t                    }nt                      }|S )Nr   )r   raises
ValueErrorr   )r   r   r   s      r   expected_dealias_errorr#   I   s5      8v%%mJ''mmJr   c           	      z    t          | |dt          j        |                                           z  d           dS )a  Assert arrays are close to within expected floating point rounding.

    Check that the result is correct at the precision expected for 64 bit
    numbers, taking account that the tolerance has to reflect that all powers
    in the FFTs enter our values.
    
           )atolrtolN)r   npspacingmaxxys     r   assert_floatcloser/   T   s8     AqrBJquuww$7$77cBBBBBBr   c            
          e Zd Zej                            ee          d             Zej                            ee          d             Z	ej                            ee          d             Z
ej                            ee          d             Zej                            ee          d             Zej                            ee          d             Z ej        dej        dgd	
           ej        dej        dgd	
          fZ ej        g dd	
           ej        g dd	
          fZ e ej        eeddee                    Zej                            edz   e          d             Zej                            ee          d             Zd Zd Zd Z d Z!d Z"ej                            ee          d             Z#dS )TestConvolve1Dc           
      t   t          j        g dd          t          j        z  }t          j        g dd          }t	          |          5  t          ||          5  t          ||||||          }|j        |j        k    sJ 	 ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )	zW
        Test that convolve_fft works correctly when input array is a Quantity
              ?      @      @      @r6         @       @float64dtype皙?g333333?r>   r   r   r   r   N)r)   arrayuphr   r#   r	   unitselfr   r   r   r   r-   r.   zs           r   test_quantityzTestConvolve1D.test_quantitya   s[    H888	JJJQTQH___I666&999 	( 	('7KKK 
( 
( %"/%5#   v'''''
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
(	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	(s6   B- (B	B-B	B-B	B--B14B1c           
      R   t          j        g dd          }t          j        dgd          }t          |          5  t          ||          5  t	          ||||||          }t          ||           ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )	zV
        Test that a unit kernel with a single element returns the same array
        r4          @      @r:   r;   r4   r?   r@   r   Nr)   rA   r   r#   r	   r/   rE   s           r   test_unity_1_nonez TestConvolve1D.test_unity_1_nonew   sG    H___I666HcU),,,&999 	( 	('7KKK 
( 
( %"/%5#   "!Q'''
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
(	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	(s6    B&B8BB	BB	BB #B c           
      T   t          j        g dd          }t          j        g dd          }t          |          5  t          ||          5  t	          ||||||          }t          ||           ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )	z|
        Test that a unit kernel with three elements returns the same array
        (except when boundary is None).
        rJ   r:   r;   r&   r4   r&   r?   r@   r   NrM   rE   s           r   test_unity_3zTestConvolve1D.test_unity_3   sI    H___I666H___I666&999 	( 	('7KKK 
( 
( %"/%5#   "!Q'''
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
(	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	(s6   B&B9BB			BB		BB!$B!c           
      v   t          j        g dd          }t          j        g dd          }t          |          5  t          ||          5  t	          ||||||          }|||f}t          j        g dd          t          j        g d	d          t          j        g d
d          t          j        g dd          d}	|	d         |	d         |	d         |	d         d}
t          |
                                          D ]}|
|         |
|d         d|d         f<   t          |
                                          D ](}|d         dk    r|
|         |
d|d         |d         f<   )t          ||
|                    ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )z
        Test that the different modes are producing the correct results using
        a uniform kernel with three elements
        r4   r&   rL   r:   r;   r4   r4   r4   r?   r@   r   r4   r5   rL   gUUUUUU?UUUUUU?r4   r5   r5   r5   rW   rW   rW   )sum_fill_zerosaverage_fill_zerossum_wrapaverage_wrapr[   r]   rZ   r\   ))r   r   T)r   r   T)r   r   F)r   r   Fr   r      N   )r)   rA   r   r#   r	   listkeysr/   )rF   r   r   r   r   r-   r.   rG   
answer_keyanswer_dictresult_dictks               r   test_uniform_3zTestConvolve1D.test_uniform_3   s    H___I666H___I666&999 %	> %	>'7KKK $> $> %"/%5#   '7GH
 ')hi&P&P&P*,(///y+ + + !#	 J J J$&H3339% % %	 	 4??S3T3>~3N4?@P4Q4?
4K  k..0011 G GA8CAK1vqt 455k..0011 I IAtv~~:Ea.T1Q41$67!![%<===I$> $> $> $> $> $> $> $> $> $> $> $> $> $> $>%	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	> %	>s7   F.D7F
F.F	F.F	F..F25F2c                    t          j        g dd          }t          j        g dd          }t          |          5  t          ||          5  t	          ||||||          }t          j        g dd          t          j        g dd          t          j        g dd          t          j        g d	d          t          j        g d
d          t          j        g dd          t          j        g d	d          t          j        g dd          d}|rd}	nd}	|dk    r|	dz  }	n|	dz  }	t          |||	                    ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )z
        Test that the different modes are producing the correct results using
        a uniform, non-unity kernel with three elements
        rS   r:   r;   )      ?rh   rh   r?   r@   r   rh   rK         ?rV   )rK   rK   rK   rY   rh   rW   rj   )sum	sum_zerossum_nozerosaverager\   r]   average_zerosaverage_nozerosro   rl   r   _wrap_zerosNrM   )
rF   r   r   r   r   r-   r.   rG   rc   rb   s
             r   test_halfity_3zTestConvolve1D.test_halfity_3   sX    H___I666H___I666&999 #	> #	>'7KKK "> "> %"/%5#   8OOO9EEE!#///!K!K!K#%8OOO9#M#M#M!x(?(?(?yQQQ "	 J J J$&H3339% % % &(X.E.E.EY%W%W%W')x0C0C0C9'U'U'U  $ '!*JJ!&Jv%%')JJ (*J!![%<===E"> "> "> "> "> "> "> "> "> "> "> "> "> "> ">#	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	> #	>s7   E6C?EE6E"	"E6%E"	&E66E:=E:c           	      ~   t          j        dt           j        dgd          }t          j        g dd          }t          |          5  t	          ||||||          }ddd           n# 1 swxY w Y   |rt          j        |d	                   sJ t          j        |          }t          |g d
           dS )
        Test that a unit kernel with three elements returns the same array
        (except when boundary is None). This version includes a NaN value in
        the original array.
        r4   rL   r:   r;   rP   r?   r   Nr_   rS   r)   rA   nanr   r	   isnan
nan_to_numr/   rF   r   r   r   r   r-   r.   rG   s           r   test_unity_3_withnanz#TestConvolve1D.test_unity_3_withnan  s    Hc263'y999H___I666&999 	 	!+!1)  A	 	 	 	 	 	 	 	 	 	 	 	 	 	 	  	"8AaD>>!!!M!!___-----   A..A25A2r4   rL   r:   r;   rS   r   )invaloutvalc           	      6   |}t          j        dgd          }t          |          5  t          ||||||          }	ddd           n# 1 swxY w Y   |rt          j        |	d                   sJ t          j        |	          }	t          |	|           dS )rv   r4   r:   r;   r?   r   Nr_   )r)   rA   r   r	   ry   rz   r/   )
rF   r   r   r   r   r~   r   r-   r.   rG   s
             r   test_unity_1_withnanz#TestConvolve1D.test_unity_1_withnan:  s     HcU),,,&999 	 	!+!1)  A	 	 	 	 	 	 	 	 	 	 	 	 	 	 	  	"8AaD>>!!!M!!V$$$$$s   AAAc                    t          j        dt           j        dgd          }t          j        g dd          }t          |          5  t	          ||||||          }ddd           n# 1 swxY w Y   |rt          j        |d	                   sJ t          j        g d
d          t          j        g d
d          t          j        g d
d          t          j        g d
d          t          j        g dd          t          j        g dd          t          j        g dd          t          j        g dd          t          j        g dd          t          j        g dd          t          j        g dd          t          j        g dd          d}t          |                                          D ]}	d|	v r||	         dz  dz  ||	dz   <   |rd}
nd}
|dk    r|
dz  }
n|
dz  }
|dk    r|
dz  }
t          j        |          }||
         |         }|dk    r|d	         rd|rdndz  |d	<   t          ||         |           dS )z
        Test that the different modes are producing the correct results using
        a uniform kernel with three elements. This version includes a NaN
        value in the original array.
        r4   rL   r:   r;   rT   r?   r   Nr_   rU   rJ   rX   rY   )r^   r^   r^   rk   rV   ri   )rl   rn   rm   sum_nozeros_interpnanro   r\   r]   average_wrap_interpnanrq   average_nozeros_interpnanrp   average_zeros_interpnanrl   rK   
_interpnanro   r   rr   rs   r   r      )
r)   rA   rx   r   r	   ry   r`   ra   isfiniter/   )rF   r   r   r   r   r-   r.   rG   rc   keyrb   posnsanswers                r   test_uniform_3_withnanz%TestConvolve1D.test_uniform_3_withnan[  s    Hc263'y999H___I666&999 	 	!+!1)  A	 	 	 	 	 	 	 	 	 	 	 	 	 	 	  	"8AaD>>!!! 8OOO9===8OOO9EEE///CCC%'XoooY%O%O%OxyAAA	BBBH%@%@%@	RRR&(hyyy	&J&J&J!x(C(C(C9UUU)+///)S)S)SX&A&A&ASSS')x+++9( ( (
 
" ((**++ 	O 	OC||2=c2BS2H32NC,./ 	"JJJv'!JJ ("JM)),&JAZ(/ V##q# $4=SS#>F1I!E(F+++++r}   c                    t          j        dt           j        dgd          }t          j        g d          }t           j                            |g d          }t          ||dd	t           j        
          }t          |g d           d S )Nr4   rL   r:   r;   r_   r_   r_   r   r_   r   maskr   r   r   r   
fill_valuer_   r^      )r)   rA   rx   mamasked_arrayr	   r/   )rF   rA   kernelr   results        r   test_nan_interpolatez#TestConvolve1D.test_nan_interpolate  s    #rvs+9===)))$$u))%iii)@@'v
 
 
 	&))),,,,,r   c                     t          j        dt           j        dgd          }t          j        g d          }t          ||ddd          }t	          |g d	           d S )
Nr4   rL   r:   r;   r   r   r   r   rV   r)   rA   rx   r	   r/   rF   rA   r   r   s       r   test_nan_fillzTestConvolve1D.test_nan_fill  r     #rvs+9===)))$$6F&Q
 
 
 	&"9"9"9:::::r   c                     t          j        dt           j        dgd          }t          j        g d          }t          ||ddd          }t	          |g d	           d S )
Nr4   rL   r:   r;   r   r   r_   r   )r4   竪?r   r   r   s       r   test_nan_fill_twoz TestConvolve1D.test_nan_fill_two  r   r   c                 j   t          j        g dd          }t          j        g d          }t           j                            |g d          }t	          ||dd	          }t          |g d
           t          ||dd	          }t          ||           t          j        g dd          }t          j        g d          }t           j                            |g d          }t	          ||dd	          }t          |g d           t          ||dd	          }t          ||           dS )zF
        Check whether convolve_fft works with masked arrays.
        rJ   r:   r;   r   r   r   r   r&   )r   r   )rh   r^   rj   )r_   r^   r_   N)r)   rA   r   r   r	   r/   r   )rF   rA   r   r   r   convolve_resultmasked_kernels          r   test_masked_arrayz TestConvolve1D.test_masked_array  sY    	:::)))$$u))%iii)@@lFVPSTTT&"7"7"7888 #&6c
 
 
 	/6222 	:::)))$$**6			*BBe]VPSTTT&))),,, #=6c
 
 
 	/622222r   c                 r    g d}g d}t          ||t          j                  }t          |g d           dS )zP
        Check if convolve_fft works when passing a normalize function.
        r   )r   r   r   )r   )r         N)r	   r)   r+   r/   r   s       r   test_normalize_functionz&TestConvolve1D.test_normalize_function  sF     		eVbfEEE&))),,,,,r   c                     t          j        g d          }t          j        dg          }d}|dz  |dz  g}|D ]A}	||	z   }
t          ||
|||          }|rt          ||           .t          |||
z             BdS )zp
        Check that if normalize_kernel is False then the normalization
        tolerance is respected.
        r   r4   g-C6?r%   )r   r   normalization_zero_tolN)r)   rA   r	   r/   )rF   r   r   r   r   rA   base_kernelnormalization_rtol
norm_errorerrr   r   s               r   test_normalization_is_respectedz.TestConvolve1D.test_normalization_is_respected  s     ##huoo " )2-/AB/FG
 	: 	:C 3&F!!1+'9  F   :!&%0000 "&%&.9999	: 	:r   N)$__name__
__module____qualname__r   markparametrizeoption_namesoptionsrH   rN   rQ   rf   rt   option_names_preserve_nanoptions_preserve_nanr|   r)   rA   rx   infinputsoutputsr`   	itertoolsproductBOUNDARY_OPTIONSNANTREATMENT_OPTIONSoptions_unity1withnanr   r   r   r   r   r   r   r    r   r   r1   r1   `   s       [\733( ( 43(* [\733( ( 43(, [\733( ( 43(. [\733/> /> 43/>b [\733-> -> 43->^ [68LMM. . NM.> 	#rvs#9555#rvs#9555F
 		222	222G !D	 	
 	
	 	 [!$779N % % %< [68LMMH, H, NMH,T- - - ; ; ;; ; ;3 3 3>- - - [\733: : 43: : :r   r1   c                      e Zd Zej                            ee          d             Zej                            ee          d             Z	ej                            ee          d             Z
ej                            ee          d             Zej                            ee          d             Zd Zd Zej                            de          d	             Zd
S )TestConvolve2Dc           
      b   t          j        g dg dg dgd          }t          j        dggd          }t          |          5  t          ||          5  t	          ||||||	          }t          ||           d
d
d
           n# 1 swxY w Y   d
d
d
           d
S # 1 swxY w Y   d
S )zD
        Test that a 1x1 unit kernel returns the same array
        rJ   r5   r6   r7   r8   r9         "@r:   r;   r4   r?   r@   r   NrM   rE   s           r   test_unity_1x1_nonez"TestConvolve2D.test_unity_1x1_none   sa    H__ooo?y
 
 
 HseWI...&999 	( 	('7KKK 
( 
( %"/%5#   "!Q'''
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
(	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	(s6   B$&B B$B	B$B	B$$B(+B(c           
      p   t          j        g dg dg dgd          }t          j        g dg dg dgd          }t          |          5  t          ||	          5  t	          ||||||
          }t          ||           ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )zl
        Test that a 3x3 unit kernel returns the same array (except when
        boundary is None).
        rJ   r   r   r:   r;   r&   r&   r&   rP   r?   r@   r   NrM   rE   s           r   test_unity_3x3zTestConvolve2D.test_unity_3x39  sy    H__ooo?y
 
 
 H__ooo?y
 
 
 '999 	( 	('7KKK 
( 
( %"/%5#   "!Q'''
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
( 
(	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	(s6   B+!&BB+B	B+B	B++B/2B/c                     t          j        g dg dg dgd          }t          j        g dg dg dgd          }t          |          5  t          ||          5  t	          |||||rt           j        nd	||
          }t          j        g dg dg dgd          }t          j        g dg dg dgd          t          j        g dg dg dgd          d}	|	d         |z  |	d<   |	d         dz  |	d<   |	d         dz  |	d<   |	d         |	d<   |rd}
nd}
|dk    r|
dz  }
n|dk    r|
dz  }
|	|
         }t          ||           ddd           n# 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )zu
        Test that the different modes are producing the correct results using
        a 3x3 uniform kernel.
        r&   r&   rL   )r4   r&   r&   r&   rK   r&   r:   r;   rT   r?   r@   r   )r   r   r   r   r   r5   r7   r5   r7   r   r7   rU   rL   r7   r6   rL   rL   rK   r7   r7   r7   rl   r\   rl   ro   r\   r   r]   average_withzerossum_withzerosr   rr   r   
_withzerosN)r)   rA   r   r#   r	   rx   r/   )rF   r   r   r   r   r-   r.   rG   wrc   rb   as               r   test_uniform_3x3zTestConvolve2D.test_uniform_3x3U  s    H__ooo?y
 
 
 H__ooo?y
 
 
 '999 )	( )	('7KKK (( (( %"/)9@rvvq%5#   H$__oooGy   8(///???K'   !#(///???K'! ! !	 	 *5U);a)?I&.9*.E.KN+3>u3E3K/0/:5/AO,# '!*JJ!&Jv%%')JJ"f,,,.J
+!!Q'''Q(( (( (( (( (( (( (( (( (( (( (( (( (( (( (()	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	( )	(s7   E3!C.EE3E	E3"E	#E33E7:E7c           	         t          j        g ddt           j        dgg dgd          }t          j        g dg dg dgd          }t          |	          5  t	          ||||||
          }ddd           n# 1 swxY w Y   |r0t          j        |d                   sJ t          j        |          }t          j        |          }t          ||           dS )z
        Test that a 3x3 unit kernel returns the same array (except when
        boundary is None). This version includes a NaN value in the original
        array.
        rJ   r5   r7   r   r:   r;   r   rP   r?   r   Nr_   r_   rw   r{   s           r   test_unity_3x3_withnanz%TestConvolve2D.test_unity_3x3_withnan  sM    H__sBFC0///B)
 
 
 H__ooo?y
 
 
 '999 	 	!+!1)  A	 	 	 	 	 	 	 	 	 	 	 	 	 	 	  	!8AdG$$$$$a  AM!!Qs   A<<B B c           
      p   t          j        g ddt           j        dgg dgd          }t          j        g dg dg dgd          }t          |          5  t	          |||||r|d	k    rt           j        nd
||          }ddd           n# 1 swxY w Y   |rt          j        |d                   sJ t          j        g dg dg dgd          }t          j        g dg dg dgd          }	t          j        g dg dg dgd          t          j        g dg dg dgd          d}
|
d         |	z  |
d<   |
d         |z  |
d<   |
d         dz  |
d<   |
d         dz  |
d<   |
d         dz  |
d<   |
d         dz  |
d <   |
d         |
d!<   |
d         d"z  dz  |
d#<   |
d         |
d$<   |
d         d"z  dz  |
d%<   |rd}nd}|d&k    r|d'z  }n|d(k    r|d)z  }|d	k    r|d*z  }|
|          t          j        t          j        |                    }t          ||         ||                    dS )+z
        Test that the different modes are producing the correct results using
        a 3x3 uniform kernel. This version includes a NaN value in the
        original array.
        r   r4   r&   r   r:   r;   rT   r?   r   r   )r   r   r   r   r   Nr   )rL   r6   rL   )r6   r9   r6   r   r   rU   r   r   r   r   rl   ro   average_interpnanr\   r9   r   r   r]   r   average_withzeros_interpnanr   	   sum_interpnansum_withzeros_interpnansum_wrap_interpnanr   rr   r   r   r   )	r)   rA   rx   r   r	   ry   wherer   r/   )rF   r   r   r   r   r-   r.   rG   w_nw_zrc   rb   r   s                r   test_uniform_3x3_withnanz'TestConvolve2D.test_uniform_3x3_withnan  se    H__sBFC0///B)
 
 
 H__ooo?y
 
 
 '999 	 	!+ /X=M3Q3QBFFWX!1)  A	 	 	 	 	 	 	 	 	 	 	 	 	 	 	  	%8AdG$$$$$ h__ooo?y
 
 
 h__ooo?y
 
 
 8 ///???C9    ///???C9  	
 
 "-U!3c!9I+6u+=+C'(0;J0G#0M,-&1*&=&CN#+6u+=+C'(5@5G#5M12'25'9O$'25'9A'='CO$1<U1C-.,7
,Ca,G#,M() 	"JJJv'!JJf$$,&JM)),&JJ Q(( 	!E(AeH-----s   +BBBc                     t          j        t          t          f          5  t	          j        g dt                    }t          ||           ddd           dS # 1 swxY w Y   dS )z_
        Test that convolve_fft raises an exception if a too-large array is passed in.
        )   r   r   r;   N)r   r!   r"   MemoryErrorr)   emptycomplexr	   )rF   arrs     r   test_big_failzTestConvolve2D.test_big_fail  s    
 ]J455 	# 	# (???':::Cc"""	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	# 	#s   .AA #A c                 d   d}t          j        |d          }d|ddddd	f<   t          j        d
d          }d|d<   t          j        t          d          5  t          ||ddd          }t          |j        |           t          ||ddd          }|j        dv sJ 	 ddd           n# 1 swxY w Y   t          ||ddd          }t          |j        t          j        |          t          j        |j                  z              t          ||ddd          }|j        dv sJ dS )z
        Test that convolve_fft pads to _next_fast_lengths and does not expand all dimensions
        to length of longest side (#11242/#10047).
        )r_   i  i  r:   r;   r4   r   iX  ib  i,  i0  )r_      r   )r   r   r   z=psf_pad was set to False, which overrides the boundary='fill'r   TF)
return_fftpsf_padfft_pad))r_       )r_   i    N))r^   r   r   )r^   r   r   )	r)   zerosr   r   r
   r	   r   shaperA   )rF   r   imgr   img_ffts        r   test_paddingzTestConvolve2D.test_padding  s    huI...#&As3wC )9555w\Q
 
 
 	E 	E #VeU  G w}e444"VeT  G =$DDDDDD	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E D$
 
 
 	7="(5//BHV\<R<R*RSSSsFtTSWXXX} @@@@@@@s   A	B11B58B5r   c           	         t          j        g dg dg dgd          }t          j        g dg dg dgd          }t          |          5  t          |||d	d
          }d d d            n# 1 swxY w Y   |dv r/t	          |t          j        g dg dg dgd                     d S |dk    r/t	          |t          j        g dg dg dgd                     d S t          d          )N)r&   r&   r5   )r4   rK   r&   )r&   rL   r&   floatr;   )r4         r4   )r  r&   r  r?   r   F)r   r   r   Nr   )r4   g      rK   )r4   r&   g      )g       r  r  r   )r&   g       r7   )r6   r&         )rK   rL   r  zInvalid boundary specification)r)   rA   r   r	   r/   r"   )rF   r   r-   r.   rG   s        r   test_non_normalized_kernelz)TestConvolve2D.test_non_normalized_kernel@  s   HoooHPWXXXH0002B2B2BC7
 
 
 '999 	 	1xvPU  A	 	 	 	 	 	 	 	 	 	 	 	 	 	 	
 ~%%%%%'7'7'79K9K9KL!       %%%'7'7'79I9I9IJ!       =>>>s   A00A47A4N)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r   r   r   r     sU       [\733( ( 43(0 [\733( ( 43(6 [\7337( 7( 437(r [68LMM!  !  NM! F [68LMM[. [. NM[.z# # # A  A  AD [Z)9::? ? ;:? ? ?r   r   r   c                    t          j        g dd          }t          j        g dd          }t          |           5  t          ||| d          }ddd           n# 1 swxY w Y   | d	v r)t	          |t          j        g d
d          d           dS | dk    r)t	          |t          j        g dd          d           dS dS )zT
    Make sure that asymmetric convolution
    functions go the right direction
    )rL   r&   r4   r   r;   r   r?   F)r   r   Nr  )r7         $@rK   r  r%   r   )r   r  r6   )r)   rA   r   r	   r   )r   r-   r.   rG   s       r   test_asymmetric_kernelr  a  s?    	...A
%(((A	"H	5	5	5 J JA5IIIJ J J J J J J J J J J J J J J >!!&q"(3C3C3C7*S*S*SUWXXXXX	V		&q"(3C3C3C7*S*S*SUWXXXXX 
	s   A!!A%(A%)r   r   r   r   r<   c           	         g d}g d}t          j        ||          }t          j        ||          }d|j        _        d|j        _        t	          |           5  t          ||| |||           ddd           n# 1 swxY w Y   t          j        t          j        ||          |k              sJ t          j        t          j        ||          |k              sJ dS )zF
    Test that convolve_fft works correctly when inputs are lists
    r3   r=   r;   Fr?   r   N)r)   rA   flags	writeabler   r	   all)	r   r   r   r   r<   rA   r   r-   r.   s	            r   test_input_unmodifiedr  u  sA   " 0//E__F
e$$$A
u%%%A AGAG	"H	5	5	5 
 
'-%	
 	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 6"(5...!3444446"(6///145555555s   A??BBc           	      2   dddt           j        dddg}g d}t          j        ||          }t          j        ||          }d|j        _        d|j        _        |                                }	|                                }
t          | 	          5  t          ||| |||
           ddd           n# 1 swxY w Y   t          j        |          }t          j        |          }| }| }t          j	        |	|         ||         k              sJ t          j	        |
|         ||         k              sJ t          j	        t          j        ||                             sJ t          j	        t          j        ||                             sJ dS )z>
    Test that convolve_fft doesn't modify the input data
    r4   r5   r6   r8   r9   r=   r;   Fr?   r   N)
r)   rx   rA   r
  r  copyr   r	   ry   r  )r   r   r   r   r<   rA   r   r-   r.   x_copyy_copyarray_is_nankernel_is_nanarray_not_nankernel_not_nans                  r   test_input_unmodified_with_nanr    s   " #sBFCc2E__F
e$$$A
u%%%A AGAG VVXXFVVXXF	"H	5	5	5 
 
'-%	
 	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 8E??LHV$$M!MM#^N6&'1]+;;<<<<<6&(An,==>>>>>6"(1\?++,,,,,6"(1]+,,-------s   B66B:=B:error_kwargr   r   r   c                    t          j        g dg dg dgd          }t          j        dggd          }t          ||d          |k                                    sJ t	          j        t                    5 }t          ||fd	di|  d d d            n# 1 swxY w Y   t          |j                  d
t          | 
                                          d          dk    sJ d S )NrJ   r   r   r   r;   r4   r   r?   r   zWith boundary='wrap', r   z cannot be enabled.)r)   rA   r	   r  r   r!   r"   strvaluer`   ra   )r  r-   r.   r   s       r   %test_convolve_fft_boundary_wrap_errorr    sF    	///???OOODERRRA
3%&&&AA///1499;;;;;	z	"	" ;cQ::F:k:::; ; ; ; ; ; ; ; ; ; ; ; ; ; ; 	CITD)9)9););$<$<Q$?TTT	U 	U 	U 	U 	U 	Us   ;BBBc                      t          j        g dg dg dgd          } t          j        dggd          }t          j        t          d          5  t          | |d	
           d d d            d S # 1 swxY w Y   d S )NrJ   r   r   r   r;   r4   z@The 'extend' option is not implemented for fft-based convolutionr   extendr?   )r)   rA   r   r!   NotImplementedErrorr	   r,   s     r   'test_convolve_fft_boundary_extend_errorr    s    
///???OOODERRRA
3%&&&A	Q
 
 
 . . 	QH----	. . . . . . . . . . . . . . . . . .s   A33A7:A7)N)NF)*r   
contextlibr   numpyr)   r   numpy.testingr   r   r   astropyr   rB   astropy.convolution.convolver   r	   astropy.utils.exceptionsr
   VALID_DTYPESr`   r   VALID_DTYPE_MATRIXr   r   NORMALIZE_OPTIONSPRESERVE_NAN_OPTIONSr   r   r   r   r   r#   r/   r1   r   r   r   r  r  r  r  r  r   r   r   <module>r*     sB       " " " " " "                     ? ? ? ? ? ? ? ? 7 7 7 7 7 7+T+)+L,GGHH ))) . 5M e} 	 L
$I.}  
  tI.}          	C 	C 	C|: |: |: |: |: |: |: |:~? ? ? ? ? ? ? ?D
 %566Y Y 76Y& NI 	 	6 6	 	6< NI 	 	(. (.	 	(.V Y%	4'89d:KL 
 
 
. . . . .r   