U
    i]}(                     @   sf  d Z ddlmZmZmZ ddlZddlZddlmZm	Z	 ddl
m  mZ ddlZddlmZmZmZmZmZ ddlmZmZmZmZmZmZ dd	d
dddddddddddgZddlmZ dddddgZee Zd2dd	Zd3d!dZd4d#d$Z d%d Z!d5d&dZ"d6d'd(Z#e#Z$d7d*d
Z%e%Z&d8d+dZ'd9d,dZ(d:d-dZ)d;d.dZ*d<d/dZ+d=d0dZ,d>d1dZ-dS )?zMiscellaneous functions for testing masked arrays and subclasses

:author: Pierre Gerard-Marchant
:contact: pierregm_at_uga_dot_edu
:version: $Id: testutils.py 3529 2007-11-13 08:01:14Z jarrod.millman $

    )divisionabsolute_importprint_functionN)ndarrayfloat_)assert_assert_allcloseassert_array_almost_equal_nulpassert_raisesbuild_err_msg   )mask_orgetmaskmasked_arraynomaskmaskedfilledalmostapproxassert_almost_equalassert_array_almost_equalassert_array_approx_equalassert_array_compareassert_array_equalassert_array_lessassert_closeassert_equalassert_equal_recordsassert_mask_equalassert_not_equalfail_if_array_equal)TestCaser!   r   r   r	   r
   Th㈵>:0yE>c                 C   s   t t| t|}t| }t|}|jjdks:|jjdkrJt|| S tt|d|d|	t
}tt|d|dd	t
}	tt||	 ||t|	  }
|
 S )a  
    Returns true if all components of a and b are equal to given tolerances.

    If fill_value is True, masked values considered equal. Otherwise,
    masked values are considered unequal.  The relative error rtol should
    be positive and << 1.0 The absolute error atol comes into play for
    those elements of b that are very small or zero; it says how small a
    must be also.

    OFcopymaskr   )r   r   r   dtypecharnpequalravelr   astyper   Z
less_equalumathZabsolute)ab
fill_valuertolZatolmd1d2xyd r9   4/usr/lib/python3/dist-packages/numpy/ma/testutils.pyr   +   s    $   c           
      C   s   t t| t|}t| }t|}|jjdks:|jjdkrJt|| S tt|d|d|	t
}tt|d|dd	t
}tt|| |d|  k}	|	 S )z
    Returns True if a and b are equal up to decimal places.

    If fill_value is True, masked values considered equal. Otherwise,
    masked values are considered unequal.

    r$   Fr%   r         $@)r   r   r   r(   r)   r*   r+   r,   r   r-   r   Zaroundabs)
r/   r0   decimalr1   r3   r4   r5   r6   r7   r8   r9   r9   r:   r   A   s      c                 C   sF   t t| t|| tt|D ] }t | | || d||f  q dS )z;
    Asserts the equality of two non-array sequences.

    
item=%r
%sN)r   lenrange)actualdesirederr_msgkr9   r9   r:   _assert_equal_on_sequencesT   s    rG   c                 C   sd   t | j|j | jjD ]H}t| |t|| }}|tk	r|tk	rt t| |t|| qdS )zI
    Asserts that two records are equal.

    Pretty crude for now.

    N)r   r(   namesoperatorgetitemr   )r/   r0   fZafZbfr9   r9   r:   r   _   s    c                 C   s  t |trt | ts$ttt| tt| t|| | D ]<\}}|| kr`td|| f t| | || d||f  q@dS t |tt	frt | tt	frt
| |ddS t | tst |tst| |g|}|| kst|dS | tkr|tk	s|tkr$| tk	r$t| |g|ddd}t|tj| dd	d
} tj|dd	d
}| j|j }}|jdkr|jdkrt
|  | ddS t| ||S )z,
    Asserts that two items are equal.

    z%s not in %s	key=%r
%sNr?   rE   r6   r7   )headerrH   FT)r&   subokS)
isinstancedictAssertionErrorreprtyper   rA   itemslisttuplerG   r   r   r   
ValueErrorr*   Zarrayr(   r)   tolistr   )rC   rD   rE   rF   imsgZactual_dtypeZdesired_dtyper9   r9   r:   r   n   sH    

  c                 C   s*  t |tr~t | ts$ttt| tt| t|| | D ]8\}}|| kr\tt|t| | || d||f  q@dS t |tt	frt | tt	frtt| t|| t
t|D ] }t| | || d||f  qdS t | tjst |tjrt| ||S t| |g|}|| ks&t|dS )z<
    Raises an assertion error if two items are equal.

    rL   Nr@   )rR   rS   rT   rU   rV   fail_if_equalrA   rW   rX   rY   rB   r*   r   r    r   )rC   rD   rE   rF   r\   r]   r9   r9   r:   r^      s&    


r^      c                 C   s^   t | tjst |tjr*t| ||||dS t| |g||d}tt||  |dksZt|dS )z~
    Asserts that two items are almost equal.

    The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal).

    )r>   rE   verbose)rE   r`   r   N)rR   r*   r   r   r   roundr=   rT   )rC   rD   r>   rE   r`   r]   r9   r9   r:   r      s      c           	      C   s   t t|t|}t|d|ddd}t|d|ddd}|tkrF|tk	sV|tkrt|tk	rtt||g|||dd}t|tjj| |	||	||||dS )zn
    Asserts that comparison between two masked arrays is satisfied.

    The comparison is elementwise.

    F)r&   r'   Z	keep_maskrP   rN   )rE   r`   rO   rH   rE   r`   rO   )
r   r   r   r   r   rZ   r*   Ztestingr   r   )	Z
comparisonr6   r7   rE   r`   rO   r1   r3   r]   r9   r9   r:   r      s(    	  c                 C   s   t tj| |||dd dS )z@
    Checks the elementwise equality of two masked arrays.

    Arrays are not equalrb   N)r   rI   __eq__r6   r7   rE   r`   r9   r9   r:   r      s
    
 c                 C   s    dd }t || |||dd dS )zT
    Raises an assertion error if two masked arrays are not equal elementwise.

    c                 S   s   t t| | S )N)r*   Zalltruer   rN   r9   r9   r:   compare   s    z$fail_if_array_equal.<locals>.comparerc   rb   Nr   )r6   r7   rE   r`   rf   r9   r9   r:   r       s    c                    s$    fdd}t || |||dd dS )|
    Checks the equality of two masked arrays, up to given number odecimals.

    The equality is checked elementwise.

    c                    s   t | |d   dS )<Returns the result of the loose comparison between x and y).r<   )r2   )r   rN   r>   r9   r:   rf      s    z*assert_array_approx_equal.<locals>.compareArrays are not almost equalrb   Nrg   r6   r7   r>   rE   r`   rf   r9   rj   r:   r      s    c                    s$    fdd}t || |||dd dS )rh   c                    s   t | | S )ri   )r   rN   rj   r9   r:   rf     s    z*assert_array_almost_equal.<locals>.comparerk   rb   Nrg   rl   r9   rj   r:   r     s    c                 C   s   t tj| |||dd dS )z7
    Checks that x is smaller than y elementwise.

    zArrays are not less-orderedrb   N)r   rI   __lt__re   r9   r9   r:   r     s
    
 c                 C   s:   | t krt|t k |t kr(t| t k t| ||d dS )z-
    Asserts the equality of two masks.

    rM   N)r   r   r   )Zm1Zm2rE   r9   r9   r:   r     s
    )Tr"   r#   )r;   T)r?   )r?   )r?   )r_   r?   T)r?   Tr?   T)r?   T)r?   T)r;   r?   T)r;   r?   T)r?   T)r?   ).__doc__Z
__future__r   r   r   rI   Znumpyr*   r   r   Znumpy.core.umathZcorer.   Znumpy.testingr   r   r	   r
   r   r   r   r   r   r   r   Z__all__maskedZunittestr!   Z__some__from_testing__all__r   r   rG   r   r   r^   r   r   r   r   r   r    r   r   r   r   r9   r9   r9   r:   <module>   sb                



'

  







