U
|
P ±da ã ) @ sb d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z m
|
Z
|
ddl Z ddl Z ddl mZmZ ddlmZ ddlmZ ddlZddlZddlmZmZmZmZmZm Z m Z m Z ddl Zddl m!Z! d d
|
d d d ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1g)Z"G d2d% d%e#Z$e$Z%dZ&e '¡ d3kZ(ej)j*d4kZ+e,ed5Z-e.ed6ddk ove- Z/ej0j1j2Z3d7d8 Z4d9d: Z5dd<dZ6d=d> Z7d?d@ Z8dAdB Z9ej*dCkrÖddEdFZ:ddHdZ;n6ejddI
dJkrdKe <¡ dLfdMdZ;ndNd Z;ejddI
dJkr<dKe <¡ dLg fdOdZ=n g fdPdZ=ddUdZ>ddVd Z?dWd Z@e A¡ ddYd
|
ZBe A¡ d dZd ZCe A¡ d¡d\d]d^d,ZDd¢d\d]d_d ZEe A¡ d£d`dZFd¤dad ZGdbd ZHdcd ZId¥dddZJded ZKddlLZLG dfdg dgeLjMZNeNdhZOdid ZPdjd ZQd¦dkdZRd§dmdZSdndo ZTd¨dqd!ZUd©drd ZVdªdsd ZWd«dtduZXdvdw ZYdxdy ZZe j[d¬dzd{Z\d|d Z]e j[dd}d~Z^dd Z_eddfddZ`G dd" d"e#Zae j[d
d' Zbe j[dd& ZcG dd# d#ejdZeG dd+ d+Zfe j[d®ddZgdd- Zhdd. Zidd Zjdd Zkdd Zldd Zmdd Zndd Zoeo Zpdd8 ZqdS )¯z*
|
Utility function to facilitate testing.
|
|
é N)ÚpartialÚwraps)ÚmkdtempÚmkstemp)ÚSkipTest)ÚWarningMessage)ÚintpÚfloat32ÚemptyÚarangeÚ
|
array_reprÚndarrayÚisnatÚarray)ÚStringIOÚ assert_equalÚassert_almost_equalÚassert_approx_equalÚassert_array_equalÚassert_array_lessÚassert_string_equalÚassert_array_almost_equalÚ assert_raisesÚ build_err_msgÚdecorate_methodsÚjiffiesÚmemusageÚprint_assert_equalÚraisesÚrundocsÚ runstringÚverboseÚmeasureÚassert_Ú assert_array_almost_equal_nulpÚassert_raises_regexÚassert_array_max_ulpÚ assert_warnsÚassert_no_warningsÚassert_allcloseÚIgnoreExceptionÚclear_and_catch_warningsr ÚKnownFailureExceptionÚtemppathÚtempdirÚIS_PYPYÚ HAS_REFCOUNTÚIS_WASMÚsuppress_warningsÚassert_array_compareÚassert_no_gc_cyclesÚ break_cyclesÚ HAS_LAPACK64Ú IS_PYSTONÚ_OLD_PROMOTIONc @ s e Zd ZdZdS )r, z<Raise this exception to mark a test as a known failing test.N©Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__© r> r> úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/testing/_private/utils.pyr, + s )Zwasm32Zwasm64ÚpypyZpyston_version_infoÚ getrefcountc C s t ¡ dkS )NÚlegacy)ÚnpZ_get_promotion_stater> r> r> r? Ú<lambda>9 ó rD c C sT d} d}z ddl }W n tk
|
r, d} Y nX |j|k r<d} | sPd| }t||S )z# Import nose only when needed.
|
T)é r r r NFzANeed nose >= %d.%d.%d for tests - see https://nose.readthedocs.io)ÚnoseÚ ImportErrorZ__versioninfo__)Z nose_is_goodZminimum_nose_versionrG Úmsgr> r> r? Ú import_nose< s
|
|
þrJ Ú c C s8 d}| s4z
|
| }W n t k
|
r* |}Y nX t|dS )aI
|
Assert that works in release mode.
|
Accepts callable msg to allow deferring evaluation until failure.
|
|
The Python built-in ``assert`` does not work when executing code in
|
optimized mode (the ``-O`` flag) - no byte-code is generated for it.
|
|
For documentation on usage, refer to the Python documentation.
|
|
TN)Ú TypeErrorÚAssertionError)ÚvalrI Ú__tracebackhide__Zsmsgr> r> r? r# R s
|
|
c C s. ddl m} || }t|ttr*td|S )a like isnan, but always raise an error if type not supported instead of
|
returning a TypeError object.
|
|
Notes
|
-----
|
isnan and other ufunc sometimes return a NotImplementedType object instead
|
of raising any exception. This function is a wrapper to make sure an
|
exception is always raised.
|
|
This should be removed once this problem is solved at the Ufunc level.r )Úisnanz!isnan not supported for this type)Ú
|
numpy.corerP Ú
|
isinstanceÚtypeÚNotImplementedrL )ÚxrP Ústr> r> r? Úgisnanf s
|
rW c C sH ddl m}m} |dd$ || }t|ttr:tdW 5 Q R X |S )a like isfinite, but always raise an error if type not supported instead
|
of returning a TypeError object.
|
|
Notes
|
-----
|
isfinite and other ufunc sometimes return a NotImplementedType object
|
instead of raising any exception. This function is a wrapper to make sure
|
an exception is always raised.
|
|
This should be removed once this problem is solved at the Ufunc level.r )ÚisfiniteÚerrstateÚignore©Úinvalidz$isfinite not supported for this type)rQ rX rY rR rS rT rL )rU rX rY rV r> r> r? Ú gisfinitex s r] c C sH ddl m}m} |dd$ || }t|ttr:tdW 5 Q R X |S )a like isinf, but always raise an error if type not supported instead of
|
returning a TypeError object.
|
|
Notes
|
-----
|
isinf and other ufunc sometimes return a NotImplementedType object instead
|
of raising any exception. This function is a wrapper to make sure an
|
exception is always raised.
|
|
This should be removed once this problem is solved at the Ufunc level.r )ÚisinfrY rZ r[ z!isinf not supported for this type)rQ r^ rY rR rS rT rL )rU r^ rY rV r> r> r? Úgisinf s r_ Úntéÿÿÿÿc C s dd l }|d kr|j}| || |d ||f¡}| ¡ }zD| ||¡} z&| |¡ | | |¡\}
|
} | W ¢W ¢S | | ¡ X W 5 | |¡ X d S )Nr ) Úwin32pdhÚ PDH_FMT_LONGZMakeCounterPathZ OpenQueryZ
|
CloseQueryZ
|
AddCounterZ RemoveCounterZCollectQueryDataZGetFormattedCounterValue) ÚobjectÚcounterÚinstanceZinumÚformatÚmachinerb ÚpathZhqZhcrS rN r> r> r? ÚGetPerformanceAttributes s
|
ÿ
|
rj Úpythonc C s dd l }tdd| ||jd S )Nr ÚProcessz Virtual Bytes)rb rj rc )Ú processNamerf rb r> r> r? r » s þé Úlinuxz/proc/z/statc C sN z2t | d}| ¡ d¡}W 5 Q R X t|d W S tk
|
rH Y dS X dS )zM
|
Return virtual memory size in bytes of the running python.
|
|
Úrú é N)ÚopenÚreadlineÚsplitÚintÚ Exception)Ú_proc_pid_statÚfÚlr> r> r? r à s c C s t dS )zK
|
Return memory usage of running python. [Not implemented]
|
|
N)ÚNotImplementedErrorr> r> r> r? r Ï s c C s~ ddl }|s| | ¡ ¡ z2t| d}| ¡ d¡}W 5 Q R X t|d W S tk
|
rx td| ¡ |d Y S X dS )ú¸
|
Return number of jiffies elapsed.
|
|
Return number of jiffies (1/100ths of a second) that this
|
process has been scheduled in user mode. See man 5 proc.
|
|
r Nrp rq é éd )ÚtimeÚappendrs rt ru rv rw )rx Ú
|
_load_timer ry rz r> r> r? r Ø s c C s2 ddl }| s| | ¡ ¡ td| ¡ | d S )r| r Nr~ )r r rv )r r r> r> r? r í s úItems are not equal:T©ZACTUALZDESIREDé c C s d| g}|rN| d¡dkrDt|dt| k rD|d d | g}n
|
| |¡ |rt| D ]²\}}t|tr|tt|d} nt} z | |}
|
W n: t k
|
rÆ } z dt
|
|j d| d }
|
W 5 d } ~ X Y nX |
|
d¡d
|
krôd |
|
¡ d d
|
¡}
|
|
|
d 7 }
|
| d|| d |
|
¡ q\d |¡S ) NÚ
|
ra éO r rq )Ú precisionz[repr failed for <z>: ú]é z...ú: )ÚfindÚlenr Ú enumeraterR r r r Úreprrw rS r: ÚcountÚjoinÚ
|
splitlines) ZarraysÚerr_msgÚheaderr! Únamesr rI ÚiÚaZr_funcrp Úexcr> r> r? r û s&
|
"
|
|
* c
|
C s¢ d}t |trt | ts(ttt| tt| t||| | ¡ D ]>\}}|| krbtt|t| | || d|d| | qFdS t |tt frôt | tt frôtt| t||| t
|
t|D ]&}t| | || d|d| | qÈdS ddl m }m }m} ddlm}
|
m} m} t | |s4t ||rBt| |||S t| |g||d } z|
|
| pf|
|
|}W n ttfk
|
r d
|
}Y nX |r|
|
| r¬| | }| | }n| }d}|
|
|rÐ| |}| |}n|}d}zt|| t|| W n tk
|
r t| Y nX |||| kr*t| zPt|}t| }t |¡jjt | ¡jjk}|rx|rx|rpW dS t| W n tttfk
|
r Y nX zt |}t | }|r¼|r¼W dS t | ¡}t |¡}|jj d ksì|jj d krôtd |dkr"| dkr"| || | ks"t| W n tttfk
|
r@ Y nX z|| ksVt| W nD t t fk
|
r } z d |j d krt| n W 5 d}~X Y nX dS )a
|
Raises an AssertionError if two objects are not equal.
|
|
Given two objects (scalars, lists, tuples, dictionaries or numpy arrays),
|
check that all elements of these objects are equal. An exception is raised
|
at the first conflicting values.
|
|
When one of `actual` and `desired` is a scalar and the other is array_like,
|
the function checks that each element of the array_like object is equal to
|
the scalar.
|
|
This function handles NaN comparisons as if NaN was a "normal" number.
|
That is, AssertionError is not raised if both objects have NaNs in the same
|
positions. This is in contrast to the IEEE standard on NaNs, which says
|
that NaN compared to anything must return False.
|
|
Parameters
|
----------
|
actual : array_like
|
The object to check.
|
desired : array_like
|
The expected object.
|
err_msg : str, optional
|
The error message to be printed in case of failure.
|
verbose : bool, optional
|
If True, the conflicting values are appended to the error message.
|
|
Raises
|
------
|
AssertionError
|
If actual and desired are not equal.
|
|
Examples
|
--------
|
>>> np.testing.assert_equal([4,5], [4,6])
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Items are not equal:
|
item=1
|
ACTUAL: 5
|
DESIRED: 6
|
|
The following comparison does not raise an exception. There are NaNs
|
in the inputs, but they are in the same positions.
|
|
>>> np.testing.assert_equal(np.array([1.0, 2.0, np.nan]), [1, 2, np.nan])
|
|
Tzkey=r
Nzitem=r )r ÚisscalarÚsignbit©Ú iscomplexobjÚrealÚimag©r! FÚMmz0cannot compare to a scalar with a different typezelementwise == comparison)!rR ÚdictrM r rS r r ÚitemsÚlistÚtupleÚrangerQ r r r Ú numpy.libr r r r r Ú
|
ValueErrorrL r rC ÚasarrayÚdtyper{ rW ÚcharÚDeprecationWarningÚ FutureWarningÚargs)ÚactualÚdesiredr r! rO Úkr r r r r r r rI Ú
|
usecomplexÚactualrÚactualiÚdesiredrÚdesirediZisdesnatZisactnatZ dtypes_matchZisdesnanZisactnanZ array_actualZ array_desiredÚer> r> r? r s¢ 2
|
|
ÿ ÿ
|
|
|
|
|
|
ÿ
|
|
|
ÿ
|
|
c C s` d}ddl }||ks\t }| | ¡ | d¡ | ||¡ | d¡ | ||¡ t| ¡ dS )aµ
|
Test if two objects are equal, and print an error message if test fails.
|
|
The test is performed with ``actual == desired``.
|
|
Parameters
|
----------
|
test_string : str
|
The message supplied to AssertionError.
|
actual : object
|
The object to test for equality against `desired`.
|
desired : object
|
The expected result.
|
|
Examples
|
--------
|
>>> np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 1])
|
>>> np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 2])
|
Traceback (most recent call last):
|
...
|
AssertionError: Test XYZ of func xyz failed
|
ACTUAL:
|
[0, 1]
|
DESIRED:
|
[0, 2]
|
|
Tr Nz failed
|
ACTUAL:
|
z
|
DESIRED:
|
)Úpprintr ÚwriterM Úgetvalue)Ú test_stringr r® rO r¶ rI r> r> r? r · s
|
|
|
é c sÒ d}ddl m} ddlm}m}m} z| p4|}
|
W n tk
|
rP d}
|
Y nX fdd} |
|
rî| r| } | } n } d} |r¦|}| }n}d}z t| |d t| |d W n tk
|
rì t| Y nX t |t
|
t fst |t
|
t fr t S zft r6t stsJt rjtr^t s~t| n ks~t| W d S W n ttfk
|
r Y nX t t d
|
d ¡krÎt| d S ) a$
|
Raises an AssertionError if two items are not equal up to desired
|
precision.
|
|
.. note:: It is recommended to use one of `assert_allclose`,
|
`assert_array_almost_equal_nulp` or `assert_array_max_ulp`
|
instead of this function for more consistent floating point
|
comparisons.
|
|
The test verifies that the elements of `actual` and `desired` satisfy.
|
|
``abs(desired-actual) < float64(1.5 * 10**(-decimal))``
|
|
That is a looser test than originally documented, but agrees with what the
|
actual implementation in `assert_array_almost_equal` did up to rounding
|
vagaries. An exception is raised at conflicting values. For ndarrays this
|
delegates to assert_array_almost_equal
|
|
Parameters
|
----------
|
actual : array_like
|
The object to check.
|
desired : array_like
|
The expected object.
|
decimal : int, optional
|
Desired precision, default is 7.
|
err_msg : str, optional
|
The error message to be printed in case of failure.
|
verbose : bool, optional
|
If True, the conflicting values are appended to the error message.
|
|
Raises
|
------
|
AssertionError
|
If actual and desired are not equal up to specified precision.
|
|
See Also
|
--------
|
assert_allclose: Compare two array_like objects for equality with desired
|
relative and/or absolute precision.
|
assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
|
|
Examples
|
--------
|
>>> from numpy.testing import assert_almost_equal
|
>>> assert_almost_equal(2.3333333333333, 2.33333334)
|
>>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not almost equal to 10 decimals
|
ACTUAL: 2.3333333333333
|
DESIRED: 2.33333334
|
|
>>> assert_almost_equal(np.array([1.0,2.3333333333333]),
|
... np.array([1.0,2.33333334]), decimal=9)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not almost equal to 9 decimals
|
<BLANKLINE>
|
Mismatched elements: 1 / 2 (50%)
|
Max absolute difference: 6.66669964e-09
|
Max relative difference: 2.85715698e-09
|
x: array([1. , 2.333333333])
|
y: array([1. , 2.33333334])
|
|
Tr )r r Fc s d } t g| dS )Nú*Arrays are not almost equal to %d decimals)r! r )r )r ©r Údecimalr® r r! r> r? Ú_build_err_msg2 s ÿz+assert_almost_equal.<locals>._build_err_msg)r½ Nç ø?ç $@)rQ r r¥ r r r r¦ r rM rR r£ r¢ r r] rW r{ rL ÚabsrC Úfloat64)r r® r½ r r! rO r r r r r° r¾ r± r² r³ r´ r> r¼ r? r à sP F
|
|
|
ÿ
|
|
|
"c C s~ d}ddl }tt| |f\} }|| kr*dS |jdd6 d| |¡| | ¡ }| d| | |¡¡¡}W 5 Q R X z || }W n tk
|
r d}Y nX z | | } W n tk
|
r¼ d} Y nX t | |g|d | |d
|
}
|
z^t
|
|rêt
|
| s2t |süt | rt |rt | s,t |
|
n|| ks,t |
|
W dS W n t tfk
|
rN Y nX | || ¡| d |d ¡krzt |
|
dS ) aa
|
Raises an AssertionError if two items are not equal up to significant
|
digits.
|
|
.. note:: It is recommended to use one of `assert_allclose`,
|
`assert_array_almost_equal_nulp` or `assert_array_max_ulp`
|
instead of this function for more consistent floating point
|
comparisons.
|
|
Given two numbers, check that they are approximately equal.
|
Approximately equal is defined as the number of significant digits
|
that agree.
|
|
Parameters
|
----------
|
actual : scalar
|
The object to check.
|
desired : scalar
|
The expected object.
|
significant : int, optional
|
Desired precision, default is 7.
|
err_msg : str, optional
|
The error message to be printed in case of failure.
|
verbose : bool, optional
|
If True, the conflicting values are appended to the error message.
|
|
Raises
|
------
|
AssertionError
|
If actual and desired are not equal up to specified precision.
|
|
See Also
|
--------
|
assert_allclose: Compare two array_like objects for equality with desired
|
relative and/or absolute precision.
|
assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
|
|
Examples
|
--------
|
>>> np.testing.assert_approx_equal(0.12345677777777e-20, 0.1234567e-20)
|
>>> np.testing.assert_approx_equal(0.12345670e-20, 0.12345671e-20,
|
... significant=8)
|
>>> np.testing.assert_approx_equal(0.12345670e-20, 0.12345672e-20,
|
... significant=8)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Items are not equal to 8 significant digits:
|
ACTUAL: 1.234567e-21
|
DESIRED: 1.2345672e-21
|
|
the evaluated condition that raises the exception is
|
|
>>> abs(0.12345670e-20/1e-21 - 0.12345672e-20/1e-21) >= 10**-(8-1)
|
True
|
|
Tr NrZ r[ g à?é
|
g z-Items are not equal to %d significant digits:)r r! rÀ rF )ÚnumpyÚmapÚfloatrY rÁ ÚpowerÚfloorÚlog10ÚZeroDivisionErrorr r] rW rM rL r{ ) r r® Z significantr r! rO rC ZscaleZ
|
sc_desiredZ sc_actualrI r> r> r? r _ sD ;"
|
|
ý
|
|
|
"é F)Ústrictc ( s> d}
|
ddl m} m} m} mm m}m}m}m } t
|
|¡}t
|
|¡}|| }}dd }dd }| df fd d
|
}zh| r|j |j ko|j |j k}n |j d kp¸|j d kp¸|j |j k}|s |j |j kräd |j d |j d}nd|j d |j d}t||g| dd}t| d}||r||r|rP|||| dd}|rÌ||||fddddO }||||fddddO }n<||rÌ||rÌ|rÌ|j j|j jkrÌ|||tdd}|jdkr|| || }}|jdkrW d S n |rW d S | ||}t|tr4|}| |g} n| ¡ } | ¡ }|dkrà| j| jtd } |jdkrr|jn| j} d| | } d | | | ¡g} |d d t t ¡ò t || }!t
|
|j t
|
j ¡rèt || }"t
|
j |!|"|!d ||!}#t!|!d ||kr| "d!t#|# ¡ n| "d!| |# ¡ |dk}$||$ rJ| }%n||!|$ t ||$ }%t!|!d ||kr| "d"t#|% ¡ n| "d"| |% ¡ W 5 Q R X W 5 Q R X d#d# $| ¡ 7 t||gdd}t|W nV t%k
|
r8 dd l&}&|& '¡ }'d$|' d% t||gdd}t%|Y nX d S )&NTr ) r Ú array2stringrP ÚinfÚbool_rY ÚallÚmaxÚobject_c S s | j jdkS )Nz?bhilqpBHILQPefdgFDG©r¨ r© ©rU r> r> r? ÚisnumberÐ s z&assert_array_compare.<locals>.isnumberc S s | j jdkS )Nr rÓ rÔ r> r> r? ÚistimeÓ s z$assert_array_compare.<locals>.istimeÚnanc s d}|| }||} ||k ¡ dkrPt| |gd| dd}t|t|tsd|jdkrl |S t|ts|jdkr |S |S dS )zHandling nan/inf.
|
|
Combine results of running func on x and y, checking that they are True
|
at the same locations.
|
|
Tz
|
x and y %s location mismatch:©rU Úy©r! r r r r N)rÐ r rM rR ÚboolÚndim)rU rÙ ÚfuncÚhasvalrO Zx_idZy_idrI )rÏ r r r r! r> r? Úfunc_assert_same_posÖ s& ÿ ýz2assert_array_compare.<locals>.func_assert_same_posr> z
|
(shapes z, z
|
mismatch)z
|
(dtypes rØ rÚ F)rÝ rÞ c s
|
|
|
kS ©Nr> ©Zxy©rÎ r> r? rD rE z&assert_array_compare.<locals>.<lambda>z+infc s
|
| kS rà r> rá râ r> r? rD rE z-infZNaT©r¨ r~ z&Mismatched elements: {} / {} ({:.3g}%)rZ )rÐ ©Úoutr¨ zMax absolute difference: zMax relative difference: r
zerror during assertion:
|
|
z
|
|
)(rQ r rÍ rP rÎ rÏ rY rÐ rÑ rÒ rC Ú
|
asanyarrayÚshaper¨ r rM rS r rÜ ÚsizerR rÛ ZravelÚsumr rg Ú
|
contextlibÚsuppressrL rÁ Ú
|
issubdtypeZunsignedintegerZminimumÚgetattrr Ústrr r¦ Ú tracebackÚ
|
format_exc)(Z
|
comparisonrU rÙ r r! r r Ú equal_nanÚ equal_infrÌ rO r rÍ rP rY rÐ rÑ rÒ ZoxZoyrÕ rÖ rß ZcondÚreasonrI ZflaggedrN ZreducedZ
|
n_mismatchZ
|
n_elementsZpercent_mismatchZremarksÚerrorZerror2Z max_abs_errorZnonzeroZ max_rel_errorrï Zefmtr> )rÏ r r rÎ r r! r? r3 Ã sÔ ,
|
|
|
% ÿ ü
|
þ
|
þ
|
|
|
ÿÿ ÿÿ
|
ÿÿ
|
þ ÿc C s d}t tj| |||d|d dS )aß
|
Raises an AssertionError if two array_like objects are not equal.
|
|
Given two array_like objects, check that the shape is equal and all
|
elements of these objects are equal (but see the Notes for the special
|
handling of a scalar). An exception is raised at shape mismatch or
|
conflicting values. In contrast to the standard usage in numpy, NaNs
|
are compared like numbers, no assertion is raised if both objects have
|
NaNs in the same positions.
|
|
The usual caution for verifying equality with floating point numbers is
|
advised.
|
|
Parameters
|
----------
|
x : array_like
|
The actual object to check.
|
y : array_like
|
The desired, expected object.
|
err_msg : str, optional
|
The error message to be printed in case of failure.
|
verbose : bool, optional
|
If True, the conflicting values are appended to the error message.
|
strict : bool, optional
|
If True, raise an AssertionError when either the shape or the data
|
type of the array_like objects does not match. The special
|
handling for scalars mentioned in the Notes section is disabled.
|
|
.. versionadded:: 1.24.0
|
|
Raises
|
------
|
AssertionError
|
If actual and desired objects are not equal.
|
|
See Also
|
--------
|
assert_allclose: Compare two array_like objects for equality with desired
|
relative and/or absolute precision.
|
assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
|
|
Notes
|
-----
|
When one of `x` and `y` is a scalar and the other is array_like, the
|
function checks that each element of the array_like object is equal to
|
the scalar. This behaviour can be disabled with the `strict` parameter.
|
|
Examples
|
--------
|
The first assert does not raise an exception:
|
|
>>> np.testing.assert_array_equal([1.0,2.33333,np.nan],
|
... [np.exp(0),2.33333, np.nan])
|
|
Assert fails with numerical imprecision with floats:
|
|
>>> np.testing.assert_array_equal([1.0,np.pi,np.nan],
|
... [1, np.sqrt(np.pi)**2, np.nan])
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not equal
|
<BLANKLINE>
|
Mismatched elements: 1 / 3 (33.3%)
|
Max absolute difference: 4.4408921e-16
|
Max relative difference: 1.41357986e-16
|
x: array([1. , 3.141593, nan])
|
y: array([1. , 3.141593, nan])
|
|
Use `assert_allclose` or one of the nulp (number of floating point values)
|
functions for these cases instead:
|
|
>>> np.testing.assert_allclose([1.0,np.pi,np.nan],
|
... [1, np.sqrt(np.pi)**2, np.nan],
|
... rtol=1e-10, atol=0)
|
|
As mentioned in the Notes section, `assert_array_equal` has special
|
handling for scalars. Here the test checks that each value in `x` is 3:
|
|
>>> x = np.full((2, 5), fill_value=3)
|
>>> np.testing.assert_array_equal(x, 3)
|
|
Use `strict` to raise an AssertionError when comparing a scalar with an
|
array:
|
|
>>> np.testing.assert_array_equal(x, 3, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not equal
|
<BLANKLINE>
|
(shapes (2, 5), () mismatch)
|
x: array([[3, 3, 3, 3, 3],
|
[3, 3, 3, 3, 3]])
|
y: array(3)
|
|
The `strict` parameter also ensures that the array data types match:
|
|
>>> x = np.array([2, 2, 2])
|
>>> y = np.array([2., 2., 2.], dtype=np.float32)
|
>>> np.testing.assert_array_equal(x, y, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not equal
|
<BLANKLINE>
|
(dtypes int64, float32 mismatch)
|
x: array([2, 2, 2])
|
y: array([2., 2., 2.], dtype=float32)
|
TzArrays are not equal)r r! r rÌ N)r3 ÚoperatorÚ__eq__)rU rÙ r r! rÌ rO r> r> r? r i s o þc sh d}ddl mmmm} ddlm ddlm fdd}t || |||d d d
|
S ) a
|
|
Raises an AssertionError if two objects are not equal up to desired
|
precision.
|
|
.. note:: It is recommended to use one of `assert_allclose`,
|
`assert_array_almost_equal_nulp` or `assert_array_max_ulp`
|
instead of this function for more consistent floating point
|
comparisons.
|
|
The test verifies identical shapes and that the elements of ``actual`` and
|
``desired`` satisfy.
|
|
``abs(desired-actual) < 1.5 * 10**(-decimal)``
|
|
That is a looser test than originally documented, but agrees with what the
|
actual implementation did up to rounding vagaries. An exception is raised
|
at shape mismatch or conflicting values. In contrast to the standard usage
|
in numpy, NaNs are compared like numbers, no assertion is raised if both
|
objects have NaNs in the same positions.
|
|
Parameters
|
----------
|
x : array_like
|
The actual object to check.
|
y : array_like
|
The desired, expected object.
|
decimal : int, optional
|
Desired precision, default is 6.
|
err_msg : str, optional
|
The error message to be printed in case of failure.
|
verbose : bool, optional
|
If True, the conflicting values are appended to the error message.
|
|
Raises
|
------
|
AssertionError
|
If actual and desired are not equal up to specified precision.
|
|
See Also
|
--------
|
assert_allclose: Compare two array_like objects for equality with desired
|
relative and/or absolute precision.
|
assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
|
|
Examples
|
--------
|
the first assert does not raise an exception
|
|
>>> np.testing.assert_array_almost_equal([1.0,2.333,np.nan],
|
... [1.0,2.333,np.nan])
|
|
>>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
|
... [1.0,2.33339,np.nan], decimal=5)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not almost equal to 5 decimals
|
<BLANKLINE>
|
Mismatched elements: 1 / 3 (33.3%)
|
Max absolute difference: 6.e-05
|
Max relative difference: 2.57136612e-05
|
x: array([1. , 2.33333, nan])
|
y: array([1. , 2.33339, nan])
|
|
>>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
|
... [1.0,2.33333, 5], decimal=5)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not almost equal to 5 decimals
|
<BLANKLINE>
|
x and y nan location mismatch:
|
x: array([1. , 2.33333, nan])
|
y: array([1. , 2.33333, 5. ])
|
|
Tr )ÚnumberÚfloat_Ú result_typer )rì )Úanyc sÜ zxt | st |rvt | }t |}||k ¡ s<W dS | j|j krTdkrbn n
|
| |kW S | | } || }W n ttfk
|
r Y nX |d}t ||¡}t| | }|jsÊ| ¡}|dd k S )NFrF g ð?r¿ rÀ )
|
r_ rÐ rè rL r{ rC ræ rÁ r¨ Zastype)rU rÙ ZxinfidZyinfidr¨ Úz©r½ rø rì Znpanyr÷ rù r> r? Úcompare1 s$
|
|
|
|
z*assert_array_almost_equal.<locals>.comparer» )r r! r r N)
|
rQ r÷ rø rù r Znumpy.core.numerictypesrì Znumpy.core.fromnumericrú r3 )rU rÙ r½ r r! rO r rý r> rü r? r Þ s N þc C s d}t tj| |||ddd dS )ag
|
Raises an AssertionError if two array_like objects are not ordered by less
|
than.
|
|
Given two array_like objects, check that the shape is equal and all
|
elements of the first object are strictly smaller than those of the
|
second object. An exception is raised at shape mismatch or incorrectly
|
ordered values. Shape mismatch does not raise if an object has zero
|
dimension. In contrast to the standard usage in numpy, NaNs are
|
compared, no assertion is raised if both objects have NaNs in the same
|
positions.
|
|
|
|
Parameters
|
----------
|
x : array_like
|
The smaller object to check.
|
y : array_like
|
The larger object to compare.
|
err_msg : string
|
The error message to be printed in case of failure.
|
verbose : bool
|
If True, the conflicting values are appended to the error message.
|
|
Raises
|
------
|
AssertionError
|
If actual and desired objects are not equal.
|
|
See Also
|
--------
|
assert_array_equal: tests objects for equality
|
assert_array_almost_equal: test objects for equality up to precision
|
|
|
|
Examples
|
--------
|
>>> np.testing.assert_array_less([1.0, 1.0, np.nan], [1.1, 2.0, np.nan])
|
>>> np.testing.assert_array_less([1.0, 1.0, np.nan], [1, 2.0, np.nan])
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not less-ordered
|
<BLANKLINE>
|
Mismatched elements: 1 / 3 (33.3%)
|
Max absolute difference: 1.
|
Max relative difference: 0.5
|
x: array([ 1., 1., nan])
|
y: array([ 1., 2., nan])
|
|
>>> np.testing.assert_array_less([1.0, 4.0], 3)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not less-ordered
|
<BLANKLINE>
|
Mismatched elements: 1 / 2 (50%)
|
Max absolute difference: 2.
|
Max relative difference: 0.66666667
|
x: array([1., 4.])
|
y: array(3)
|
|
>>> np.testing.assert_array_less([1.0, 2.0, 3.0], [4])
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not less-ordered
|
<BLANKLINE>
|
(shapes (3,), (1,) mismatch)
|
x: array([1., 2., 3.])
|
y: array([4])
|
|
TzArrays are not less-orderedF)r r! r rò N)r3 rõ Ú__lt__)rU rÙ r r! rO r> r> r? r P s L ýc C s t | | d S rà )Úexec)Zastrr r> r> r? r £ s c C s d}ddl }t| ts&ttt| t|ts@ttt||| krLdS t| ¡ | d¡| d¡¡}g }|rP|
|
d¡}| d¡rqp| d¡rB|g}|
|
d¡}| d¡rÆ| |¡ |
|
d¡}| d¡sÜtt|| |¡ |r|
|
d¡} | d¡r| | ¡ n | d| ¡ |dd
|dd
kr6qp| |¡ qptt|qp|sZdS d d
|
|¡ ¡ }
|
| |krt|
|
dS ) a
|
Test if two strings are equal.
|
|
If the given strings are equal, `assert_string_equal` does nothing.
|
If they are not equal, an AssertionError is raised, and the diff
|
between the strings is shown.
|
|
Parameters
|
----------
|
actual : str
|
The string to test for equality against the expected string.
|
desired : str
|
The expected string.
|
|
Examples
|
--------
|
>>> np.testing.assert_string_equal('abc', 'abc')
|
>>> np.testing.assert_string_equal('abc', 'abcd')
|
Traceback (most recent call last):
|
File "<stdin>", line 1, in <module>
|
...
|
AssertionError: Differences in strings:
|
- abc+ abcd? +
|
|
Tr Nz z- z? z+ é zDifferences in strings:
|
rK )ÚdifflibrR rî rM r rS r¢ ZDifferrý r ÚpopÚ
|
startswithr ÚinsertÚextendr Úrstrip) r r® rO r ÚdiffZ diff_listÚd1rz Zd2Zd3rI r> r> r? r § sP
|
|
ÿ
|
|
|
|
|
|
|
|
|
|
|
c s ddl m} ddl}| dkr0t d¡}|jd } tj tj | ¡¡d }||| }|
|
¡ |¡}|j dd}g |r fdd } nd} |D ]}
|
|j |
|
| d
|
q|jdkr¾|r¾td d ¡ dS ) aV
|
Run doctests found in the given file.
|
|
By default `rundocs` raises an AssertionError on failure.
|
|
Parameters
|
----------
|
filename : str
|
The path to the file for which the doctests are run.
|
raise_on_error : bool
|
Whether to raise an AssertionError when a doctest fails. Default is
|
True.
|
|
Notes
|
-----
|
The doctests can be run by the user/developer by adding the ``doctests``
|
argument to the ``test()`` call. For example, to run all tests (including
|
doctests) for `numpy.lib`:
|
|
>>> np.lib.test(doctests=True) # doctest: +SKIP
|
r )Úexec_mod_from_locationNrF Ú__file__Fr c s
|
| ¡S rà )r )Ús©rI r> r? rD rE zrundocs.<locals>.<lambda>rä zSome doctests failed:
|
%sr
)Znumpy.distutils.misc_utilr ÚdoctestÚsysÚ _getframeÚ f_globalsÚosri ÚsplitextÚbasenameZ DocTestFinderr Z DocTestRunnerÚrunZfailuresrM r ) ÚfilenameZraise_on_errorr r ry ÚnameÚmÚtestsÚrunnerrå Útestr> r r? r î s"
|
|
|
c G s t }|jj| S )a Decorator to check for raised exceptions.
|
|
The decorated test function must raise one of the passed exceptions to
|
pass. If you want to test many assertions about exceptions in a single
|
test, you may want to use `assert_raises` instead.
|
|
.. warning::
|
This decorator is nose specific, do not use it if you are using a
|
different test framework.
|
|
Parameters
|
----------
|
args : exceptions
|
The test passes if any of the passed exceptions is raised.
|
|
Raises
|
------
|
AssertionError
|
|
Examples
|
--------
|
|
Usage::
|
|
@raises(TypeError, ValueError)
|
def test_raises_type_error():
|
raise TypeError("This test passes")
|
|
@raises(Exception)
|
def test_that_fails_by_passing():
|
pass
|
|
)rJ Ztoolsr )r¬ rG r> r> r? r s "c @ s e Zd Zdd ZdS )Ú_Dummyc C s d S rà r> )Úselfr> r> r? ÚnopH s z
|
_Dummy.nopN)r: r; r< r r> r> r> r? r G s r r c O s d}t j| |S )aá
|
assert_raises(exception_class, callable, *args, **kwargs)
|
assert_raises(exception_class)
|
|
Fail unless an exception of class exception_class is thrown
|
by callable when invoked with arguments args and keyword
|
arguments kwargs. If a different type of exception is
|
thrown, it will not be caught, and the test case will be
|
deemed to have suffered an error, exactly as for an
|
unexpected exception.
|
|
Alternatively, `assert_raises` can be used as a context manager:
|
|
>>> from numpy.testing import assert_raises
|
>>> with assert_raises(ZeroDivisionError):
|
... 1 / 0
|
|
is equivalent to
|
|
>>> def div(x, y):
|
... return x / y
|
>>> assert_raises(ZeroDivisionError, div, 1, 0)
|
|
T)Ú_dÚ assertRaises)r¬ ÚkwargsrO r> r> r? r M s c O s d}t j| |f||S )aë
|
assert_raises_regex(exception_class, expected_regexp, callable, *args,
|
**kwargs)
|
assert_raises_regex(exception_class, expected_regexp)
|
|
Fail unless an exception of class exception_class and with message that
|
matches expected_regexp is thrown by callable when invoked with arguments
|
args and keyword arguments kwargs.
|
|
Alternatively, can be used as a context manager like `assert_raises`.
|
|
Notes
|
-----
|
.. versionadded:: 1.9.0
|
|
T)r ÚassertRaisesRegex)Zexception_classZexpected_regexpr¬ r rO r> r> r? r% j s c s´ |dkrt dtj ¡}n
|
t |¡}| j}ddlm fdd| ¡ D }|D ]^}z t|drh|j }n|j
|
}W n t k
|
r Y qPY nX | |¡rP| d¡sPt| ||| qPdS ) a
|
Apply a decorator to all methods in a class matching a regular expression.
|
|
The given decorator is applied to all public methods of `cls` that are
|
matched by the regular expression `testmatch`
|
(``testmatch.search(methodname)``). Methods that are private, i.e. start
|
with an underscore, are ignored.
|
|
Parameters
|
----------
|
cls : class
|
Class whose methods to decorate.
|
decorator : function
|
Decorator to apply to methods
|
testmatch : compiled regexp or str, optional
|
The regular expression. Default value is None, in which case the
|
nose default (``re.compile(r'(?:^|[\b_\.%s-])[Tt]est' % os.sep)``)
|
is used.
|
If `testmatch` is a string, it is compiled to a regular expression
|
first.
|
|
Nz(?:^|[\\b_\\.%s-])[Tt]estr ©Ú
|
isfunctionc s g | ]} |r|qS r> r> )Ú.0Ú_mr" r> r? Ú
|
<listcomp> s z$decorate_methods.<locals>.<listcomp>Úcompat_func_nameÚ_)ÚreÚcompiler ÚsepÚ__dict__Úinspectr# ÚvaluesÚhasattrr' r: ÚAttributeErrorÚsearchr Úsetattr)ÚclsÚ decoratorZ testmatchZcls_attrÚmethodsÚfunctionÚfuncnamer> r" r? r s
|
|
|
|
rF c C sf t d¡}|j|j }}t| d| dd}d}t }||k rT|d7 }t||| q6t | }d| S )aG
|
Return elapsed time for executing code in the namespace of the caller.
|
|
The supplied code string is compiled with the Python builtin ``compile``.
|
The precision of the timing is 10 milli-seconds. If the code will execute
|
fast on this timescale, it can be executed many times to get reasonable
|
timing accuracy.
|
|
Parameters
|
----------
|
code_str : str
|
The code to be timed.
|
times : int, optional
|
The number of times the code is executed. Default is 1. The code is
|
only compiled once.
|
label : str, optional
|
A label to identify `code_str` with. This is passed into ``compile``
|
as the second argument (for run-time error messages).
|
|
Returns
|
-------
|
elapsed : float
|
Total elapsed time in seconds for executing `code_str` `times` times.
|
|
Examples
|
--------
|
>>> times = 10
|
>>> etime = np.testing.measure('for i in range(1000): np.sqrt(i**2)', times=times)
|
>>> print("Time for a single execution : ", etime / times, "s") # doctest: +SKIP
|
Time for a single execution : 0.005 s
|
|
rF z Test name: rq rÿ r g{®Gáz?)r r Úf_localsr r* r rÿ ) Zcode_strÚtimesÚlabelÚframeZlocsZglobsÚcoder Úelapsedr> r> r? r" ® s !
|
|
c C s t sdS ddl}ddl}| d¡ dd¡}|}d}| ¡ z8t |¡}t dD ]}| ||}qNt
|
t |¡|k W 5 | ¡ X ~dS )zg
|
Check that ufuncs don't mishandle refcount of object `1`.
|
Used in a few regression tests.
|
Tr Ni' r~ rF é ) r0 ÚgcrÄ r ZreshapeÚdisableÚenabler rA r¤ r# ) Úopr? rC ÚbÚcr ÚrcÚjÚdr> r> r? Ú_assert_valid_refcountÜ s
|
|
rH çH¯¼ò×z>c
|
sf d}ddl fdd} | ¡ |¡ } }ddd d} t|| |t||| d dS )
|
añ
|
Raises an AssertionError if two objects are not equal up to desired
|
tolerance.
|
|
Given two array_like objects, check that their shapes and all elements
|
are equal (but see the Notes for the special handling of a scalar). An
|
exception is raised if the shapes mismatch or any values conflict. In
|
contrast to the standard usage in numpy, NaNs are compared like numbers,
|
no assertion is raised if both objects have NaNs in the same positions.
|
|
The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
|
that ``allclose`` has different default values). It compares the difference
|
between `actual` and `desired` to ``atol + rtol * abs(desired)``.
|
|
.. versionadded:: 1.5.0
|
|
Parameters
|
----------
|
actual : array_like
|
Array obtained.
|
desired : array_like
|
Array desired.
|
rtol : float, optional
|
Relative tolerance.
|
atol : float, optional
|
Absolute tolerance.
|
equal_nan : bool, optional.
|
If True, NaNs will compare equal.
|
err_msg : str, optional
|
The error message to be printed in case of failure.
|
verbose : bool, optional
|
If True, the conflicting values are appended to the error message.
|
|
Raises
|
------
|
AssertionError
|
If actual and desired are not equal up to specified precision.
|
|
See Also
|
--------
|
assert_array_almost_equal_nulp, assert_array_max_ulp
|
|
Notes
|
-----
|
When one of `actual` and `desired` is a scalar and the other is
|
array_like, the function checks that each element of the array_like
|
object is equal to the scalar.
|
|
Examples
|
--------
|
>>> x = [1e-5, 1e-3, 1e-1]
|
>>> y = np.arccos(np.cos(x))
|
>>> np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)
|
|
Tr Nc s j jj| | dS )N)ÚrtolÚatolrñ )ÚcoreÚnumericÚiscloserØ ©rK rñ rC rJ r> r? rý 2 s ÿz assert_allclose.<locals>.comparez Not equal to tolerance rtol=Úgz, atol=)r r! r rñ )rÄ ræ r3 rî )
|
r r® rJ rK rñ r r! rO rý r r> rO r? r) ö s 9 ÿc
|
C s d}ddl }| | ¡}| |¡}|| | ||k||¡¡ }| | | | ¡|k¡s| | ¡sh| |¡rrd| }n | t| |¡} d|| f }t|dS )aÚ
|
Compare two arrays relatively to their spacing.
|
|
This is a relatively robust method to compare two arrays whose amplitude
|
is variable.
|
|
Parameters
|
----------
|
x, y : array_like
|
Input arrays.
|
nulp : int, optional
|
The maximum number of unit in the last place for tolerance (see Notes).
|
Default is 1.
|
|
Returns
|
-------
|
None
|
|
Raises
|
------
|
AssertionError
|
If the spacing between `x` and `y` for one or more elements is larger
|
than `nulp`.
|
|
See Also
|
--------
|
assert_array_max_ulp : Check that all items of arrays differ in at most
|
N Units in the Last Place.
|
spacing : Return the distance between x and the nearest adjacent number.
|
|
Notes
|
-----
|
An assertion is raised if the following condition is not met::
|
|
abs(x - y) <= nulp * spacing(maximum(abs(x), abs(y)))
|
|
Examples
|
--------
|
>>> x = np.array([1., 1e-10, 1e-20])
|
>>> eps = np.finfo(x.dtype).eps
|
>>> np.testing.assert_array_almost_equal_nulp(x, x*eps/2 + x)
|
|
>>> np.testing.assert_array_almost_equal_nulp(x, x*eps + x)
|
Traceback (most recent call last):
|
...
|
AssertionError: X and Y are not equal to 1 ULP (max is 2)
|
|
Tr Nz X and Y are not equal to %d ULPz+X and Y are not equal to %d ULP (max is %g)) rÄ rÁ ÚspacingÚwhererÐ r rÑ Ú nulp_diffrM )
|
rU rÙ ZnulprO rC ZaxZayÚrefrI Zmax_nulpr> r> r? r$ < s 1
|
|
|
c C s@ d}ddl }t| ||}| ||k¡s<td|| |¡f |S )ai
|
Check that all items of arrays differ in at most N Units in the Last Place.
|
|
Parameters
|
----------
|
a, b : array_like
|
Input arrays to be compared.
|
maxulp : int, optional
|
The maximum number of units in the last place that elements of `a` and
|
`b` can differ. Default is 1.
|
dtype : dtype, optional
|
Data-type to convert `a` and `b` to if given. Default is None.
|
|
Returns
|
-------
|
ret : ndarray
|
Array containing number of representable floating point numbers between
|
items in `a` and `b`.
|
|
Raises
|
------
|
AssertionError
|
If one or more elements differ by more than `maxulp`.
|
|
Notes
|
-----
|
For computing the ULP difference, this API does not differentiate between
|
various representations of NAN (ULP difference between 0x7fc00000 and 0xffc00000
|
is zero).
|
|
See Also
|
--------
|
assert_array_almost_equal_nulp : Compare two arrays relatively to their
|
spacing.
|
|
Examples
|
--------
|
>>> a = np.linspace(0., 1., 100)
|
>>> res = np.testing.assert_array_max_ulp(a, np.arcsin(np.sin(a)))
|
|
Tr NzCArrays are not almost equal up to %g ULP (max difference is %g ULP))rÄ rS rÐ rM rÑ )r rC Zmaxulpr¨ rO rC Úretr> r> r? r& { s * þc sî ddl |r* j| |d} j||d}n | ¡} |¡} | |¡} | ¡s^ |¡rftd j| g|d} j|g|d} j| | ¡< j| |¡< | j|jksÆt d| j|jf fdd}t
|
| }t
|
|}||||S )an For each item in x and y, return the number of representable floating
|
points between them.
|
|
Parameters
|
----------
|
x : array_like
|
first input array
|
y : array_like
|
second input array
|
dtype : dtype, optional
|
Data-type to convert `x` and `y` to if given. Default is None.
|
|
Returns
|
-------
|
nulp : array_like
|
number of representable floating point numbers between each item in x
|
and y.
|
|
Notes
|
-----
|
For computing the ULP difference, this API does not differentiate between
|
various representations of NAN (ULP difference between 0x7fc00000 and 0xffc00000
|
is zero).
|
|
Examples
|
--------
|
# By definition, epsilon is the smallest number such as 1 + eps != 1, so
|
# there should be exactly one ULP between 1 and 1 + eps
|
>>> nulp_diff(1, 1 + np.finfo(x.dtype).eps)
|
1.0
|
r Nrã z'_nulp not implemented for complex arrayz+x and y do not have the same shape: %s - %sc s j | | |d} |¡S ©Nrã )r§ rÁ )ÚrxÚryÚvdtr ©rC r> r? Ú_diffå s znulp_diff.<locals>._diff) rÄ r§ Z common_typer r{ r r× rP rç r¦ Ú integer_repr)rU rÙ r¨ Útr[ rW rX r> rZ r? rS ¯ s*
|
|
|
ÿ rS c C sB | |¡}|jdks.|||dk ||dk < n|dk r>|| }|S )NrF r )Úviewrè )rU rY ÚcomprW r> r> r? Ú _integer_reprî s
|
|
r` c C s| ddl }| j|jkr(t| |j| d¡S | j|jkrHt| |j| d¡S | j|jkrht| |j| d¡S t d| j dS )zQReturn the signed-magnitude interpretation of the binary representation
|
of x.r Ni ÿÿi lûÿÿÿ zUnsupported dtype )
|
rÄ r¨ Úfloat16r` Úint16r Úint32r Úint64r¦ )rU rC r> r> r? r\ ý s r\ c c sX d}t D}| | ¡}d V t|dksJ|d k r:d| nd}td| W 5 Q R X d S )NTr ú when calling rK zNo warning raised)r2 Úrecordr rM )Ú warning_classr rO Úsuprz Úname_strr> r> r? Ú_assert_warns_context s
|
rj c
|
O sP |s t | S |d }|dd
}t | |jd |||W 5 Q R £ S Q R X dS )a+
|
Fail unless the given callable throws the specified warning.
|
|
A warning of class warning_class should be thrown by the callable when
|
invoked with arguments args and keyword arguments kwargs.
|
If a different type of warning is thrown, it will not be caught.
|
|
If called with all arguments other than the warning class omitted, may be
|
used as a context manager:
|
|
with assert_warns(SomeWarning):
|
do_something()
|
|
The ability to be used as a context manager is new in NumPy v1.11.0.
|
|
.. versionadded:: 1.4.0
|
|
Parameters
|
----------
|
warning_class : class
|
The class defining the warning that `func` is expected to throw.
|
func : callable, optional
|
Callable to test
|
*args : Arguments
|
Arguments for `func`.
|
**kwargs : Kwargs
|
Keyword arguments for `func`.
|
|
Returns
|
-------
|
The value returned by `func`.
|
|
Examples
|
--------
|
>>> import warnings
|
>>> def deprecated_func(num):
|
... warnings.warn("Please upgrade", DeprecationWarning)
|
... return num*num
|
>>> with np.testing.assert_warns(DeprecationWarning):
|
... assert deprecated_func(4) == 16
|
>>> # or passing a func
|
>>> ret = np.testing.assert_warns(DeprecationWarning, deprecated_func, 4)
|
>>> assert ret == 16
|
r rF N©r )rj r: )rg r¬ r rÝ r> r> r? r' s - c c sf d}t jddL}t d¡ d V t|dkrX| d k r@d| nd}td| d| W 5 Q R X d S ) NT©rf Úalwaysr re rK z Got warningsr )ÚwarningsÚcatch_warningsÚ simplefilterr rM )r rO rz ri r> r> r? Ú_assert_no_warnings_contextL s
|
rq c
|
O sL | s
|
t S | d }| dd
} t |jd || |W 5 Q R £ S Q R X dS )a:
|
Fail if the given callable produces any warnings.
|
|
If called with all arguments omitted, may be used as a context manager:
|
|
with assert_no_warnings():
|
do_something()
|
|
The ability to be used as a context manager is new in NumPy v1.11.0.
|
|
.. versionadded:: 1.7.0
|
|
Parameters
|
----------
|
func : callable
|
The callable to test.
|
\*args : Arguments
|
Arguments passed to `func`.
|
\*\*kwargs : Kwargs
|
Keyword arguments passed to `func`.
|
|
Returns
|
-------
|
The value returned by `func`.
|
|
r rF Nrk )rq r: ©r¬ r rÝ r> r> r? r( W s Úbinaryé c
|
# sº d}d}t dD ]¢t d td |D ]|dkrt fdd}tf dd
}|| | d
|
f fV | }||| d f fV |d d
| d d
|d d d
|
f fV |d d
| d d
|d d d
|
f fV | d d
| d d
|d d df fV | d d
| d d
|d d df fV |dkr. fdd} fdd} tf dd
}|| | | d
|
f fV | }||| | df fV | }|| || df fV |d d
| d d
| d d
|d d d
|
f fV |d d
| d d
| d d
|d d d
|
f fV |d d
| d d
| d d
|d d d
|
f fV | d d
| d d
| d d
|d d df fV | d d
| d d
| d d
|d d df fV | d d
| d d
| d d
|d d df fV q.qd S )aÓ
|
generator producing data with different alignment and offsets
|
to test simd vectorization
|
|
Parameters
|
----------
|
dtype : dtype
|
data type to produce
|
type : string
|
'unary': create data for unary operations, creates one input
|
and output array
|
'binary': create data for unary operations, creates two input
|
and output array
|
max_size : integer
|
maximum size of data to produce
|
|
Returns
|
-------
|
if type is 'unary' yields one output, one input array and a message
|
containing information on the data
|
if type is 'binary' yields one output array, two input array and a message
|
containing information on the data
|
|
z,unary offset=(%d, %d), size=%d, dtype=%r, %sz1binary offset=(%d, %d, %d), size=%d, dtype=%r, %sr r Zunaryc s t dd
S rV ©r r> ©r¨ Úor r> r? rD rE z%_gen_alignment_data.<locals>.<lambda>rã Nz out of placezin placerF ra Úaliasedrs c s t dd
S rV ru r> rv r> r? rD § rE c s t dd
S rV ru r> rv r> r? rD ¨ rE z in place1z in place2)r¤ rÑ r
|
)
|
r¨ rS Úmax_sizeZufmtZbfmtÚinprå rG Zinp1Zinp2r> rv r? Ú_gen_alignment_data{ sn
|
ÿÿÿÿ ÿ
|
ÿ
|
ÿ$ÿ$ÿ$ÿ&ÿ&ÿ&ÿr{ c @ s e Zd ZdZdS )r* z/Ignoring this exception due to disabled featureNr9 r> r> r> r? r* À s c o s& t | |}z
|
|V W 5 t |¡ X dS )zContext manager to provide a temporary test folder.
|
|
All arguments are passed as this to the underlying tempfile.mkdtemp
|
function.
|
|
N)r ÚshutilÚrmtree)r¬ r Ztmpdirr> r> r? r. Å s
|
|
c o s4 t | |\}}t |¡ z
|
|V W 5 t |¡ X dS )aç Context manager for temporary files.
|
|
Context manager that returns the path to a closed temporary file. Its
|
parameters are the same as for tempfile.mkstemp and are passed directly
|
to that function. The underlying file is removed when the context is
|
exited, so it should be closed at that time.
|
|
Windows does not allow a temporary file to be opened if it is already
|
open, so the underlying file must be closed after opening before it
|
can be opened again.
|
|
N)r r ÚcloseÚremove)r¬ r Úfdri r> r> r? r- Ô s
|
|
|
c s> e Zd ZdZdZd
|
fdd Z fddZ fdd Z ZS ) r+ a< Context manager that resets warning registry for catching warnings
|
|
Warnings can be slippery, because, whenever a warning is triggered, Python
|
adds a ``__warningregistry__`` member to the *calling* module. This makes
|
it impossible to retrigger the warning in this module, whatever you put in
|
the warnings filters. This context manager accepts a sequence of `modules`
|
as a keyword argument to its constructor and:
|
|
* stores and removes any ``__warningregistry__`` entries in given `modules`
|
on entry;
|
* resets ``__warningregistry__`` to its previous state on exit.
|
|
This makes it possible to trigger any warning afresh inside the context
|
manager without disturbing the state of warnings outside.
|
|
For compatibility with Python 3.0, please consider all arguments to be
|
keyword-only.
|
|
Parameters
|
----------
|
record : bool, optional
|
Specifies whether warnings should be captured by a custom
|
implementation of ``warnings.showwarning()`` and be appended to a list
|
returned by the context manager. Otherwise None is returned by the
|
context manager. The objects appended to the list are arguments whose
|
attributes mirror the arguments to ``showwarning()``.
|
modules : sequence, optional
|
Sequence of modules for which to reset warnings registry on entry and
|
restore on exit. To work correctly, all 'ignore' filters should
|
filter by one of these modules.
|
|
Examples
|
--------
|
>>> import warnings
|
>>> with np.testing.clear_and_catch_warnings(
|
... modules=[np.core.fromnumeric]):
|
... warnings.simplefilter('always')
|
... warnings.filterwarnings('ignore', module='np.core.fromnumeric')
|
... # do something that raises a warning but ignore those in
|
... # np.core.fromnumeric
|
r> Fc s* t | | j¡| _i | _t j|d d S )Nrl )ÚsetÚunionÚ class_modulesÚmodulesÚ_warnreg_copiesÚsuperÚ__init__)r rf r ©Ú __class__r> r? r s z!clear_and_catch_warnings.__init__c s< | j D ]*}t|dr|j}| ¡ | j|< | ¡ qt ¡ S ©NÚ__warningregistry__)r r/ r Úcopyr
Úclearr Ú __enter__)r ÚmodZmod_regr r> r? r s
|
|
|
z"clear_and_catch_warnings.__enter__c sL t j| | jD ]4}t|dr*|j ¡ || jkr|j | j| ¡ qd S r )r Ú__exit__r r/ r r r
Úupdate)r Úexc_infor r r> r? r # s
|
|
|
|
z!clear_and_catch_warnings.__exit__)Fr> ) r: r; r< r= r r r r Ú __classcell__r> r> r r? r+ ê s
|
) c @ sz e Zd ZdZdddZdd Zeddd fd
|
d Zeddfd d ZeddfddZ dd Z
|
dd Z ddddZ dd Z dS )r2 aÙ
|
Context manager and decorator doing much the same as
|
``warnings.catch_warnings``.
|
|
However, it also provides a filter mechanism to work around
|
https://bugs.python.org/issue4180.
|
|
This bug causes Python before 3.4 to not reliably show warnings again
|
after they have been ignored once (even within catch_warnings). It
|
means that no "ignore" filter can be used easily, since following
|
tests might need to see the warning. Additionally it allows easier
|
specificity for testing warnings and can be nested.
|
|
Parameters
|
----------
|
forwarding_rule : str, optional
|
One of "always", "once", "module", or "location". Analogous to
|
the usual warnings module filter mode, it is useful to reduce
|
noise mostly on the outmost level. Unsuppressed and unrecorded
|
warnings will be forwarded based on this rule. Defaults to "always".
|
"location" is equivalent to the warnings "default", match by exact
|
location the warning warning originated from.
|
|
Notes
|
-----
|
Filters added inside the context manager will be discarded again
|
when leaving it. Upon entering all filters defined outside a
|
context will be applied automatically.
|
|
When a recording filter is added, matching warnings are stored in the
|
``log`` attribute as well as in the list returned by ``record``.
|
|
If filters are added and the ``module`` keyword is given, the
|
warning registry of this module will additionally be cleared when
|
applying it, entering the context, or exiting it. This could cause
|
warnings to appear a second time after leaving the context if they
|
were configured to be printed once (default) and were already
|
printed before the context was entered.
|
|
Nesting this context manager will work as expected when the
|
forwarding rule is "always" (default). Unfiltered and unrecorded
|
warnings will be passed out and be matched by the outer level.
|
On the outmost level they will be printed (or caught by another
|
warnings context). The forwarding rule argument can modify this
|
behaviour.
|
|
Like ``catch_warnings`` this context manager is not threadsafe.
|
|
Examples
|
--------
|
|
With a context manager::
|
|
with np.testing.suppress_warnings() as sup:
|
sup.filter(DeprecationWarning, "Some text")
|
sup.filter(module=np.ma.core)
|
log = sup.record(FutureWarning, "Does this occur?")
|
command_giving_warnings()
|
# The FutureWarning was given once, the filtered warnings were
|
# ignored. All other warnings abide outside settings (may be
|
# printed/error)
|
assert_(len(log) == 1)
|
assert_(len(sup.log) == 1) # also stored in log attribute
|
|
Or as a decorator::
|
|
sup = np.testing.suppress_warnings()
|
sup.filter(module=np.ma.core) # module must match exactly
|
@sup
|
def some_function():
|
# do something which causes a warning in np.ma.core
|
pass
|
rm c C s& d| _ g | _|dkr td|| _d S )NF> Úmodulerm ÚonceÚlocationz unsupported forwarding rule.)Ú_enteredÚ _suppressionsr¦ Ú_forwarding_rule)r Zforwarding_ruler> r> r? r v s
|
zsuppress_warnings.__init__c C s: t tdrt ¡ d S | jD ]}t |dr |j ¡ q d S )NÚ_filters_mutatedr )r/ rn r Ú _tmp_modulesr r )r r r> r> r? Ú_clear_registries s
|
|
|
z#suppress_warnings._clear_registriesrK NFc C s¬ |r
|
g }nd }| j r|d kr.tjd||d n8|j dd¡d }tjd|||d | j |¡ | ¡ | j ||t
|
|t
|
j ¡||f¡ n | j ||t
|
|t
|
j ¡||f¡ |S )Nrm ©ÚcategoryÚmessageÚ.ú\.ú$©r r r )r rn Úfilterwarningsr: Úreplacer Úaddr Ú_tmp_suppressionsr r) r* ÚIr )r r r r rf Ú module_regexr> r> r? Ú_filter s4 ÿ þ ÿÿzsuppress_warnings._filterc C s | j |||dd dS )a§
|
Add a new suppressing filter or apply it if the state is entered.
|
|
Parameters
|
----------
|
category : class, optional
|
Warning class to filter
|
message : string, optional
|
Regular expression matching the warning message.
|
module : module, optional
|
Module to filter for. Note that the module (and its file)
|
must match exactly and cannot be a submodule. This may make
|
it unreliable for external modules.
|
|
Notes
|
-----
|
When added within a context, filters are only added inside
|
the context and will be forgotten when the context is exited.
|
F©r r r rf N©rª ©r r r r r> r> r? Úfilter¥ s
|
ÿzsuppress_warnings.filterc C s | j |||ddS )ai
|
Append a new recording filter or apply it if the state is entered.
|
|
All warnings matching will be appended to the ``log`` attribute.
|
|
Parameters
|
----------
|
category : class, optional
|
Warning class to filter
|
message : string, optional
|
Regular expression matching the warning message.
|
module : module, optional
|
Module to filter for. Note that the module (and its file)
|
must match exactly and cannot be a submodule. This may make
|
it unreliable for external modules.
|
|
Returns
|
-------
|
log : list
|
A list which will be filled with all matched warnings.
|
|
Notes
|
-----
|
When added within a context, filters are only added inside
|
the context and will be forgotten when the context is exited.
|
Tr« r¬ r r> r> r? rf ¼ s
|
ÿzsuppress_warnings.recordc C sÖ | j rtdtj| _tj| _| jd d
t_d| _ g | _t | _ t | _
|
g | _ | j D ]j\}}}}}|d k rv|d d
= |d krtj d||d qV|j dd¡d }tj d|||d | j |¡ qV| jt_| ¡ | S ) Nz%cannot enter suppress_warnings twice.Trm r r r¡ r¢ r£ )r Ú RuntimeErrorrn Ú showwarningÚ
|
_orig_showÚfiltersÚ_filtersr§ r r Ú
|
_forwardedÚlogr r¤ r: r¥ r¦ Ú _showwarningr )r ÚcatZmessr( r rµ r© r> r> r? r Ú s<
|
ÿ þzsuppress_warnings.__enter__c G s* | j t_| jt_| ¡ d| _| ` | `d S )NF)r± rn r° r³ r² r r )r r r> r> r? r ú s zsuppress_warnings.__exit__)Ú use_warnmsgc O s | j | j d d d
D ]¬\}} }
|
} } t||r|
|
|jd ¡d k r| d kr| d k rzt||||f|} | j | ¡ | | ¡ d S | j |¡r| d k r¼t||||f|} | j | ¡ | | ¡ d S q| j
|
dkr |d krò| j ||||f|| n
|
| |¡ d S | j
|
dkr|j|f}n4| j
|
dkr2|j||f}n| j
|
dkrL|j|||f}|| j kr\d S | j |¡ |d kr| j ||||f|| n
|
| |¡ d S )Nra r rm r r r )r r§ Ú
|
issubclassÚmatchr¬ r rµ r r
|
r r r± Z _orig_showmsgr´ r¦ )r r r r Úlinenor¸ r¬ r r· r( Úpatternr ZrecrI Ú signaturer> r> r? r¶ sd
|
ÿÿ
|
ÿÿÿ
|
ÿÿ
|
ÿÿ
|
|
ÿz suppress_warnings._showwarningc s t fdd}|S )z_
|
Function decorator to apply certain suppressions to a whole
|
function.
|
c
|
s& | |W 5 Q R £ S Q R X d S rà r> )r¬ r ©rÝ r r> r? Únew_func: s z,suppress_warnings.__call__.<locals>.new_func©r )r rÝ r¿ r> r¾ r? Ú__call__5 s zsuppress_warnings.__call__)rm )r: r; r< r= r r ÚWarningrª r® rf r r r¶ rÁ r> r> r> r? r2 , s I
|
|
ÿ 3c
|
c sè d}t sd V d S tt ¡ t ¡ t ¡ }zRt dD ]}t
|
¡ dkr8 qVq8t dt tj ¡ d V t
|
¡ }tjd d
}W 5 tjd d
= t |¡ t ¡ X |rä| d k r¸d| nd}t d ||t|d dd |D ¡¡d S )
|
NTr~ r z]Unable to fully collect garbage - perhaps a __del__ method is creating more reference cycles?re rK zXReference cycles were found{}: {} objects were collected, of which {} are shown below:{}c s s4 | ],}d t|jt|t |¡ dd¡¡V qdS )z
|
{} object with id={}:
|
{}r
z
|
N)rg rS r: Úidr¶ Úpformatr¥ )r$ rw r> r> r? Ú <genexpr>k s üýz/_assert_no_gc_cycles_context.<locals>.<genexpr>)r0 r# r? Ú isenabledr@ Z get_debugÚgarbageZ set_debugrA r¤ Úcollectr¯ Z DEBUG_SAVEALLrM rg r r )r rO Zgc_debugr Zn_objects_in_cyclesZobjects_in_cyclesri r> r> r? Ú _assert_no_gc_cycles_contextB sB ÿ
|
|
|
ûúÿrÉ c O sD | s
|
t S | d }| dd
} t |jd || | W 5 Q R X dS )a3
|
Fail if the given callable produces any reference cycles.
|
|
If called with all arguments omitted, may be used as a context manager:
|
|
with assert_no_gc_cycles():
|
do_something()
|
|
.. versionadded:: 1.15.0
|
|
Parameters
|
----------
|
func : callable
|
The callable to test.
|
\*args : Arguments
|
Arguments passed to `func`.
|
\*\*kwargs : Kwargs
|
Keyword arguments passed to `func`.
|
|
Returns
|
-------
|
Nothing. The result is deliberately discarded to ensure that all cycles
|
are found.
|
|
r rF Nrk )rÉ r: rr r> r> r? r4 v s c C s0 t ¡ tr,t ¡ t ¡ t ¡ t ¡ dS )a1
|
Break reference cycles by calling gc.collect
|
Objects can call other objects' methods (for instance, another object's
|
__del__) inside their own __del__. On PyPy, the interpreter only runs
|
between calls to gc.collect, so multiple calls are needed to completely
|
release all cycles.
|
N)r? rÈ r/ r> r> r> r? r5 s c s ddl fdd}|S )z:Decorator to skip a test if not enough memory is availabler Nc s t fdd}|S )Nc sJ t }|d k r |¡ z | |W S tk
|
rD d¡ Y nX d S )NzMemoryError raised)Úcheck_free_memoryÚskipÚ MemoryErrorZxfail)r ÚkwrI )Ú
|
free_bytesrÝ Úpytestr> r? Úwrapper¯ s
|
z3requires_memory.<locals>.decorator.<locals>.wrapperrÀ ©rÝ rÐ ©rÎ rÏ ©rÝ r? r4 ® s z"requires_memory.<locals>.decorator)rÏ )rÎ r4 r> rÒ r? Úrequires_memoryª s rÔ c
|
C s² d}t j |¡}|dk rrz t|}W n6 tk
|
rZ } ztd| d| W 5 d}~X Y nX | d d| d}n0t }|dkrd}d }n| d d
|
|d d }|| k r®|S dS ) z
|
Check whether `free_bytes` amount of memory is currently free.
|
Returns: None if enough memory available, otherwise error message
|
ZNPY_AVAILABLE_MEMNz Invalid environment variable r g eÍÍAz@ GB memory required, but environment variable NPY_AVAILABLE_MEM=z setzCould not determine available memory; set NPY_AVAILABLE_MEM environment variable (e.g. NPY_AVAILABLE_MEM=16GB) to run the test.ra z GB memory required, but z GB available)r ÚenvironÚgetÚ _parse_sizer¦ Ú_get_mem_available)rÎ Úenv_varZ env_valueZmem_freer rI r> r> r? rÊ À s &rÊ c C s dddddddddddddd d
|
}t d d | ¡ ¡¡t j¡}| | ¡ ¡}|r`| d ¡|krpt d| dt
|
t | d¡|| d ¡ S )z3Convert memory size strings ('12 GB' etc.) to floatrF iè i@B i Ê;l J)£é i i @l )rK rC r¯ r rP r] ÚkbÚmbÚgbÚtbZkibZmibZgibZtibz ^\s*(\d+|\d+\.\d+)\s*({0})\s*$ú|r zvalue z not a valid size) r) r* rg r Úkeysr¨ rº ÚlowerÚgroupr¦ rv rÆ )Zsize_strÚsuffixesZsize_rer r> r> r? r× Ý s. ý ÿÿr× c C s¬ zddl } | ¡ jW S ttfk
|
r, Y nX tj d¡r¨i }tdd:}|D ].}| ¡ }t
|
|d d ||d d¡ ¡ < qNW 5 Q R X d |kr|d S |d
|
|d S dS ) z5Return available memory in bytes, or None if unknown.r Nro z /proc/meminforp rF rÚ ú:Z memavailableZmemfreeÚcached) ÚpsutilZvirtual_memoryÚ availablerH r0 r Úplatformr rs ru rv Ústriprá )ræ Úinfory ÚlineÚpr> r> r? rØ í s .rØ c s* t tds S t fdd}|S dS )zµ
|
Decorator to temporarily turn off tracing for the duration of a test.
|
Needed in tests that check refcounting, otherwise the tracing itself
|
influences the refcounts
|
Úgettracec s2 t ¡ }zt d ¡ | |W ¢S t |¡ X d S rà )r rí Úsettrace)r¬ r Zoriginal_tracerÓ r> r? rÐ
|
s
|
|
z _no_tracing.<locals>.wrapperN)r/ r r rÑ r> rÓ r? Ú _no_tracing
|
s
|
|
rï c
|
C sD zt d¡ d¡d } W n& tk
|
r> } zd} W 5 d }~X Y nX | S )NÚCS_GNU_LIBC_VERSIONrq rF ú0.0)r ÚconfstrÚrsplitrw )ÚverÚinstr> r> r? Ú_get_glibc_version
|
s
|
rö c C s t dkot | k S )Nrñ )Ú _glibcverrÔ r> r> r? rD #
|
rE )rK )Nra NN)rk r )r Tr r )rK T)rº rK T)rº rK T)rK TrK rË TT)rK T)rË rK T)rK T)NT)N)rF N)rI r TrK T)rF )rF N)N)N)N)N)rr= r r rè r) r? rõ rn Ú functoolsr r r| rê Útempfiler r Z unittest.caser r r¶ rÄ rC rQ r r r
|
r r r r r Znumpy.linalg.lapack_liteÚior Ú__all__rw r, ZKnownFailureTestr! rh r1 Úimplementationr r/ r/ r7 rí r0 ZlinalgZ lapack_liteZ_ilp64r6 r8 rJ r# rW r] r_ rj r Úgetpidr r r r Z_no_nep50_warningr r r3 r r r r r r r ZunittestZTestCaser r r r% r r" rH r) r$ r& rS r` r\ Úcontextmanagerrj r' rq r( r{ r* r. r- ro r+ r2 rÉ r4 r5 rÔ rÊ r× rØ rï rö r÷ Z_glibc_older_thanr> r> r> r? Ú<module> sB ( ô
|
|
|
ÿ
|
ÿ
|
|
!) ~ c ÿþ &u q
|
SG
|
.(
|
/
|
. ÿ
|
F
|
?
|
4
|
?
|
6
|
$E
|
|
B 3"
|
