Ë
|
Kñúh¢ ã óÜ d Z ddlZddlZddlZddlZddlZddlZddl Z ddl
|
Z
|
ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlmZmZ ddlmZ ddlmZmZ ddlmZ ddlm Z ddl Z ddl Z ddl m Z m!Z!m"Z" dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ g d
|
¢Z, G d d e-« Z.e.Z/dZ0 e jb e jd « jf Z4 ejj jm d « Z7dZ8 ejr dk\ r!e7jt jv jx Z=nFddl>Z>ddl?Z? e>j e7j d« xs dd ¬« Z:e:jv jx Z=e=se7j d « e4k7 rdZ8 e
|
j « dv ZFej j dk( ZI eJed« ZK eLedd« duxr eK ZMdZN e
|
j « dk( s e
|
j « dk( r' e j j¢ d d ZReRd d k( rdZNe j¨ jª j¬ ZWdZX ej² d « xs d ZZd!eZv rdZX e[ ej² d"« « Z\ e jº e jR « j¼ d#k( Z_dfd$Z`ej d%k( r dgd&Zadhd'Zbnej dd( d)k( rdid*Zbnd+ Zbej dd( d)k( rdjd,Zcng fd-Zc dkd/Zddldd0d1Zed2 Zfdmd3Zg dmd4Zh dndd.d5d6Zidldd0d7Zj dod8Zkdldd0d9Zld: Zmd; Zndpd<Zog fd=ZpddlqZq G d> d?eqjä « Zs esd@« ZtdA ZudB ZvdidCZwdqdDZxdE Zy drdd0dFZzdsdGZ{dqdHZ|didIZ}dJ Z~dK Zej didL« ZdM Zej didN« ZdO Ze(dPdQfdRZ
G dS dTe-« Zej dU « Zej dV « Z G dW dXej « Z G dY dZ« Zej did[« Zd\ Zd] Zd^ Zd_ Zd` Zda Zdb Zdc Z e« Zdd Z dtdeZy# eB$ r dZ=Y åw xY w# ejj j $ r dxZ8Z=Y ðw xY w# eS$ r Y ew xY w)uz*
|
Utility function to facilitate testing.
|
|
é N)ÚpartialÚwraps)ÚStringIO)ÚmkdtempÚmkstemp)ÚSkipTest)ÚWarningMessage)ÚisfiniteÚisinfÚisnan)ÚarangeÚarrayÚ
|
array_reprÚemptyÚfloat32ÚintpÚisnatÚndarray)0Ú 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Ú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ÚIS_MUSLÚcheck_support_sveÚ NOGIL_BUILDÚ IS_EDITABLEÚ IS_INSTALLEDÚ
|
NUMPY_ROOTÚ run_threadedÚIS_64BITÚBLAS_SUPPORTS_FPEc ó e Zd ZdZy)r/ z<Raise this exception to mark a test as a known failing test.N©Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__© ó úOH:\Change_password\venv_build\Lib\site-packages\numpy/testing/_private/utils.pyr/ r/ 1 s ÙFØrK r/ ÚnumpyT)é é zdirect_url.jsonz{}c ó, t j di | ¤S )NrJ )ÚtypesÚSimpleNamespace)Údatas rL ú<lambda>rT J s ¬×)>Ñ)>Ñ)FÀÑ)F rK )Ú object_hookF)Úwasm32Úwasm64ÚpypyÚpyston_version_infoÚ getrefcountÚDarwinÚarm64zBuild DependenciesÚblasÚnameÚ
|
accelerateÚ HOST_GNU_TYPEÚ ÚmuslÚPy_GIL_DISABLEDé c óh d}| s |« }t |« y# t $ r |}Y t |« w xY w)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)ÚvalÚmsgÚ__tracebackhide__Úsmsgs rL r& r& t sL ð ÐÙ ð Ù5Dô TÓ"Ð"ð øô ò ØDÜ TÓ"Ð"ð ús 1°1Úntc ó dd l }| |j }|j || |d ||f« }|j « } |j ||« } |j |« |j | |« \ }
|
} | |j | « |j |« S # |j | « w xY w# |j |« w xY w)Nr ) Úwin32pdhÚ PDH_FMT_LONGÚMakeCounterPathÚ OpenQueryÚ
|
AddCounterÚCollectQueryDataÚGetFormattedCounterValueÚ RemoveCounterÚ
|
CloseQuery) ÚobjectÚcounterÚinstanceÚinumÚformatÚmachinern ÚpathÚhqÚhcÚtyperh s rL ÚGetPerformanceAttributesr sÇ ó Ø >Ø ×*Ñ*FØ×'Ñ'¨°&¸(ÀDØ)-¨wð)8ó 9à × Ñ Ó !ð $Ø×$Ñ$ R¨Ó.Bð +Ø×)Ñ)¨"Ô-Ø $× =Ñ =¸bÀ&Ó I cØà×&Ñ& rÔ*à × Ñ Õ #øð ×&Ñ& rÕ*ûà × Ñ Õ #ús# »B. Á'B Á5B. ÂB+Â+B. Â.Cc ó> dd l }t dd| ||j d « S )Nr ÚProcessz Virtual Bytes)rn r ro )Ú processNamery rn s rL r r ¦ s( ãÜ'¨ °?Ø(3°XØ(0×(=Ñ(=¸tóEð ErK é Úlinuxc óô | xs dt j « d} t | « 5 }|j « j d« }ddd« t d « S # 1 sw Y xY w# t $ r Y yw xY w)zM
|
Return virtual memory size in bytes of the running python.
|
|
ú/proc/ú/statú Né )ÚosÚgetpidÚopenÚreadlineÚsplitÚintÚ Exception)Ú_proc_pid_statÚfÚls rL r r ® sx ð
|
(ÒF¨V´B·I±I³K°=ÀÐ+Fð ÜnÓ%ð ,¨ØJJL×&Ñ& sÓ+÷ ,äqu:Ð ÷ ,ð ,ûô ò Ù ð ús( A+ © A Á A+ Á A(Á$A+ Á+ A7Á6A7c ó t )zK
|
Return memory usage of running python. [Not implemented]
|
|
)ÚNotImplementedErrorrJ rK rL r r » s
|
ô
|
"Ð!rK c ó | xs dt j « d} |xs g }ddl}|s |j |j « « t | « 5 }|j « j d« }ddd« t d « S # 1 sw Y xY w# t $ r% t d|j « |d z
|
z « cY S w xY w)ú¸
|
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 r r Nr rO éd ) r r ÚtimeÚappendr r r r r )r Ú
|
_load_timer r r s rL r r Ä s¸ ð (ÒF¨V´B·I±I³K°=ÀÐ+FØ Ò% 2
|
ÛÙØ × Ñ diikÔ *ð <ÜnÓ%ð ,¨ØJJL×&Ñ& sÓ+÷ ,äqu:Ð ÷ ,ð ,ûô ò <Üsdiik¨J°q©MÑ 9Ñ:Ó;Ò ;ð <ús* Á B Á B
|
Á4B Â
|
BÂB Â+CÃCc ó ddl }| s | j |j « « t d|j « | d z
|
z « S )r r Nr )r r r )r r s rL r r Û s= ó ÙØ × Ñ diikÔ *Ü3$))+¨
|
°1© Ñ5Ñ6Ó7Ð7rK ©ÚACTUALÚDESIREDc ó| d|z g}t |« }|rL|j d« dk( r't |« dt |« z
|
k r |d dz |z g}n|j |« |rt | « D ] \ }}t |t « rt t |¬« } nt } | |« }
|
|
|
j d« d
|
kD r'dj |
|
j « d d
|
« }
|
|
|
d z }
|
|j d|| d |
|
« dj |« S # t $ r&} dt |« j d| d }
|
Y d } ~ d } ~ ww xY w) Nú
|
éÿÿÿÿéO r r )Ú precisionz[repr failed for <z>: ú]rN z...ú: )ÚstrÚfindÚlenr Ú enumerateÚ
|
isinstancer r r Úreprr r rF ÚcountÚjoinÚ
|
splitlines) ÚarraysÚerr_msgÚheaderr$ Únamesr¦ ri ÚiÚaÚr_funcÚrÚexcs rL r r é s: à &=/CÜ'lGÙØ <<Ó Ò #¬¨G« °r¼CÀ»KÑ7GÒ(GØq6C< 'Ñ)Ð*Cà JJwÔ ÙÜ fÓ%ò ,DAqä!WÔ%ä ¤°yÔAä ð EÙ1Ið wwt}qÒ ØIIalln¨R¨aÐ 0Ó1ØU
|
Ø JJ5 8* B q cÐ*Õ +ð ,ð 99S>Ðøô ò EØ(¬¨a«×)9Ñ)9Ð(:¸#¸c¸UÀ!ÐDûð Eús  D Ä D;Ä D6Ä6D;©Ústrictc ó d}t |t « rt | t « s t t t | « « « t t | « t |« ||« |j « D ]7 \ }}|| vrt t |« « t | | || d|d| |« 9 yt |t t f« rjt | t t f« rTt t | « t |« ||« t t |« « D ] }t | | || d|d| |« yddl m }m } m}
|
ddlm} m} m} t | | « s t || « rt' | ||||¬ « S t) | |g||¬
|
« } | | « xs | |« }|rS | | « r |
|
| « } || « }n| }d} | |« r |
|
|« } ||« }n|}d} t ||« t ||« | |« | | « k7 r t |« t/ |« }t/ | « }t1 j2 |« j4 j t1 j2 | « j4 j k( }|r|r|ryt |« t9 |« }t9 | « }|r|ryt1 j2 | « }t1 j2 |« }|j4 j: d v s|j4 j: d v r t7 d « |dk( r!| dk( r | |« | | « k( s t |« || k( s t |« y# t* t, f$ r d }Y ºw xY w# t $ r t |« w xY w# t, t* t6 f$ r Y ÿw xY w# t, t* t6 f$ r Y rw xY w# t< t> f$ r"}d|j@ d v r t |« d}~ww xY w)ah
|
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.
|
|
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.
|
strict : bool, optional
|
If True and either of the `actual` and `desired` arguments is an array,
|
raise an ``AssertionError`` when either the shape or the data type of
|
the arguments does not match. If neither argument is an array, this
|
parameter has no effect.
|
|
.. versionadded:: 2.0.0
|
|
Raises
|
------
|
AssertionError
|
If actual and desired are not equal.
|
|
See Also
|
--------
|
assert_allclose
|
assert_array_almost_equal_nulp,
|
assert_array_max_ulp,
|
|
Notes
|
-----
|
By default, when one of `actual` and `desired` is a scalar and the other is
|
an array, the function checks that each element of the array is equal to
|
the scalar. This behaviour can be disabled by setting ``strict==True``.
|
|
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])
|
|
As mentioned in the Notes section, `assert_equal` has special
|
handling for scalars when one of the arguments is an array.
|
Here, the test checks that each value in `x` is 3:
|
|
>>> x = np.full((2, 5), fill_value=3)
|
>>> np.testing.assert_equal(x, 3)
|
|
Use `strict` to raise an AssertionError when comparing a scalar with an
|
array of a different shape:
|
|
>>> np.testing.assert_equal(x, 3, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not equal
|
<BLANKLINE>
|
(shapes (2, 5), () mismatch)
|
ACTUAL: array([[3, 3, 3, 3, 3],
|
[3, 3, 3, 3, 3]])
|
DESIRED: 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_equal(x, y, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not equal
|
<BLANKLINE>
|
(dtypes int64, float32 mismatch)
|
ACTUAL: array([2, 2, 2])
|
DESIRED: array([2., 2., 2.], dtype=float32)
|
Tzkey=r£ Nzitem=r ©ÚimagÚ iscomplexobjÚreal)Úisscalarr Úsignbitr» ©r$ FÚMmz0cannot compare to a scalar with a different typezelementwise == comparison)!r Údictrg r® r r r« ÚitemsÚlistÚtupleÚrangerM r¿ rÀ rÁ Ú numpy._corer r rà r r Ú
|
ValueErrorrf r ÚnpÚasarrayÚdtyper r ÚcharÚDeprecationWarningÚ FutureWarningÚargs) ÚactualÚdesiredr³ r$ r¼ rj Úkr¶ r¿ rÀ rÁ r r rà ri Ú
|
usecomplexÚactualrÚactualiÚdesiredrÚdesirediÚisdesnatÚisactnatÚ dtypes_matchÚisdesnanÚisactnanÚ array_actualÚ array_desiredÚes rL r r sÇ ðF ÐÜ'4Ô Ü&¤$Ô'Ü ¤¤d¨6£lÓ!3Ó4Ð 4ÜS[¤# g£,°¸ÔAØMMOò "DAqØÜ$¤T¨!£WÓ-Ð-Ü G¨A¡J°$°q°e¸2¸g¸YÐ0GØ õ "ð "ð
|
Ü'D¤%=Ô)¬j¸Ä$ÌÀ Ô.OÜS[¤# g£,°¸ÔAÜs7|Ó$ò "AÜ G¨A¡J°%¸°u¸B¸w¸iÐ0HØ õ "ð "ð ß.Ñ.ß6Ñ6Ü&'Ô"¤j°¸'Ô&BÜ! &¨'°7¸GØ)/ô1ð 1ä
|
Ð)¨7¸GÔ
|
DCð
|
Ù! &Ó)ÒB©\¸'Ó-B
|
ñ Ù Ô Ù6lGÙ6lGà GØGÙ Ô ÙG}HÙG}Hà HØHð &Ü (Ô +Ü (Ô +ñ
|
ÓH VÓ ,Ò,Ü SÓ!Ð!ð Ü>Ü=Ü
|
|
7Ó+×1Ñ1×6Ñ6Ü
|
|
6Ó*×0Ñ0×5Ñ5ñ6 á ñ Øä$ SÓ)Ð)ð Ü>Ü=Ù Ø ô zz &Ó) Ü
|
|
7Ó+ Ø × Ñ × #Ñ # tÑ +Ø ×#Ñ#×(Ñ(¨DÑ0ô &ð '>ó ?ð ?ð a<F aKÙ7Ó#¡w¨v£Ò6Ü$ SÓ)Ð)ð
|
|
à6Ò!Ü Ó%Ð %ð "øôO Ð "ò Ø
|
ðûô& ò &Ü Ó%Ð %ð &ûô( zÔ#6Ð 7ò Ù ð ûô6 zÔ#6Ð 7ò Ù ð ûô ¤ Ð .ò à &¨!¯&©&°©)Ñ 3Ü Ó%Ð %à ûð úsh Å8L0 ÇM Ç<A/M É, M É8M: ÊB M: Ì N Ì0MÍMÍM Í M7Í6M7Í:NÎNÎOÎ# O Ï Oc ó d}ddl }||k( s|t « }|j | « |j d« |j ||« |j d« |j ||« t |j « « y)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 Úwriterg Úgetvalue)Ú test_stringrÔ rÕ rj rå ri s rL r! r! Ø sw ð8 ÐÛà gÒ ÜjØ +Ô Ø Ð'Ô(Ø fcÔ"Ø -Ô Ø gsÔ#Ü S\\^Ó,Ð,ð rK c óh d}ddl m}m}m} ddlm} | « xs |« }
|
fd} |
|
rW | « r | « } | « } n } d} |« r |« } |« }n}d} t | |¬« t | |¬« t | t t f« st | t t f« rt « S t « r t « sSt « s t « r't « r t « st | « « y k( st | « « y t# z
|
« t% j& d d
|
z z « k\ rt | « « y# t $ r d}
|
Y Sw xY w# t $ r t | « « w xY w# t t f$ r Y |w xY w) aN
|
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 among violations: 6.66669964e-09
|
Max relative difference among violations: 2.85715698e-09
|
ACTUAL: array([1. , 2.333333333])
|
DESIRED: array([1. , 2.33333334])
|
|
Tr r¾ )r Fc ó0 dz } t g| ¬« S )Nú*Arrays are not almost equal to %d decimals)r$ r´ )r )r´ rÔ ÚdecimalrÕ r³ r$ s rL Ú_build_err_msgz+assert_almost_equal.<locals>._build_err_msgR s( ø Ø>ÀÑHÜ f gÐ .°ÀØ$*ô,ð ,rK )rì Nç ø?ç $@)rM r¿ rÀ rÁ rË r rÌ r rg r rÉ rÈ r r
|
r r rf ÚabsrÍ Úfloat64)rÔ rÕ rì r³ r$ rj r¿ rÀ rÁ r r× rí rØ rÙ rÚ rÛ s ````` rL r r sÄ ü ðJ Ðß.Ñ.Ý#ð
|
Ù! &Ó)ÒB©\¸'Ó-B
|
÷,ð ,ñ
|
Ù Ô Ù6lGÙ6lGà GØGÙ Ô ÙG}HÙG}Hà HØHð 3Ü ¨¸7Õ CÜ ¨¸7Õ Cô &7¤E¬4Ð0Ô1Ü' G¬U´DÐ#9Ô:Ü(¨°¸'À7ÓKÐKð ô Ô!¤h¨vÔ&6ÜW~¤ v¤ Ü g¬5°¬=Ü(© Ó)9Ó:Ð:ð ð Ò&Ü$¡^Ó%5Ó6Ð6Ø ð '7ô 7VÑ Ó ¤§
|
¡
|
¨3°¸¸Ñ1AÑ+AÓ BÒBÜ ^Ó -Ó.Ð.ð CøôW ò Ø
|
ðûô0 ò 3Ü ¡ Ó!1Ó2Ð 2ð 3ûô" ¤Ð +ò Ù ð ús6 E0 Á1 F Ã
|
AF Ä F Å0 E?Å>E?ÆF Æ F1Æ0F1c ó, d}ddl }t t | |f« \ } }|| k( ry |j d¬« 5 d |j |« |j | « z z } |j
|
d |j |j |« « « }ddd« |z } | z } t | |g|d |z |¬
|
« }
|
t |« r t | « sIt |« s t | « r"t |« r t | « s t |
|
« y|| k( s t |
|
« y |j || z
|
« |j
|
d |d z
|
« k\ r t |
|
« y# 1 sw Y ÃxY w# t $ r d}Y Íw xY w# t $ r d} Y Øw xY w# t t f$ r Y xw xY w) 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 NÚignore)Úinvalidg à?é
|
g z-Items are not equal to %d significant digits:)r´ r$ rï é )rM ÚmapÚfloatÚerrstaterð ÚpowerÚfloorÚlog10ÚZeroDivisionErrorr r
|
r rg rf r ) rÔ rÕ Ú significantr³ r$ rj rÍ ÚscaleÚ
|
sc_desiredÚ sc_actualri s rL r r ~ sº ðv ÐÛäE F¨GÐ#4Ó5ÑVWØ&ÒØð
|
XÔ &ñ 8Øvrvvg¨¨¯©°« Ñ7Ñ8ØXRXX h b§h¡h¨u£oÓ 6Ó7÷8ðØ u_
|
ðØUN ô Ø Ð7Ø>ÀÑLØô Cð ô Ô!¤h¨vÔ&6ÜW~¤ v¤ Ü g¬5°¬=Ü(¨Ó-Ð-ð ð Ò&Ü$ SÓ)Ð)Ø ð '7ð rvvj9Ñ$Ó%¨¨¯©°#¸Àq¹ Ð7IÓ)JÒJÜ SÓ!Ð!ð K÷98ð 8ûô
|
ò Ø
|
ðûô ò Ø ðûô" Ô*Ð +ò Ù ð úsI µA EÂE Â E0 Â:A F ÄF ÅE Å E-Å,E-Å0 E>Å=E>ÆFÆF)r¼ rµ c óö
|
2 d} ddl m} m} m}m2m}m}m} t j |« }t j |« }||}}d }d }d }|df
|
fd } | r5|j |j k( xr |j |j k( }n;|j d k( xs |j d k( xs |j |j k( }|su|j |j k7 r d
|
|j d |j d }n d |j d |j d }t ||g|z
|
¬« }t |« t j d« } ||« r? ||« r7|r ||||d¬« }|r&| |||2fdd¬« z }| |||2fdd¬« z }n ||« rH ||« r@|rî|j j |j j k( rÁ |||t d¬« }n° ||« r¨ ||« r |j } |r| |j k( rt# | d« rwt% | j& t( « xr t j
|
| j& « } d} t | j& « | s| r |||||j j& ¬« }|j, dkD r || || }}|j. dk( ry |ry | ||« } t j0 | « } t% | t « r| }t3 | g« }!n | j5 « }!|!j « }|dk7 rT|!j. |!j7 t8 ¬« z
|
}"|j, dk7 r |j. n |!j. }#d|"z |#z }$d|" d|# d |$d d g}% |d ¬ « 5 t; j< t* « 5 t? ||z
|
« }&t j@ |j t jB « r&t? ||z
|
« }'t jD |&|'|&¬!« |&| }( ||(« })tG |&d"|« |k( r |%jI d#tK |)« z « n|%jI d# | |)« z « t j |dk7 « }*t jL | |*« }+ | |+ « r t3 2« },n>|&|+ }-t jN ||&j « }.|.|+ }/ ||-t? |/« z « },tG |&d"|« |k( r |%jI d$tK |,« z « n|%jI d$ | |,« z « d d d « d d d « tK « d%d%jQ |%« z z t ||g
|
¬« }t |« y # t* $ r d} Y w xY w# 1 sw Y dxY w# 1 sw Y hxY w# tR $ r; dd l*}0|0jW « }1d&|1 d' t ||g
|
¬« }tS |« w xY w)(NTr )ÚallÚ array2stringrù Úinfr ÚmaxÚobject_c ó2 | j j dv S )Nz?bhilqpBHILQPefdgFDG©rÏ rÐ ©Úxs rL Úisnumberz&assert_array_compare.<locals>.isnumberí s Øww||Ð 5Ð5Ð5rK c ó2 | j j dv S )NrÅ r r
|
s rL Úistimez$assert_array_compare.<locals>.istimeð s Øww||tÐ#Ð#rK c ó4 | j j dk( S )NÚTr r
|
s rL Ú isvstringz'assert_array_compare.<locals>.isvstringó s Øww||sÑ"Ð"rK Únanc ó d} || « } ||« }t j ||k( « j « dk7 r$t | |gd|z z
|
¬« }t |« t |t « s|j dk( rt j |« S t |t « s|j dk( rt j |« S |S )zHandling nan/inf.
|
|
Combine results of running func on x and y, checking that they are True
|
at the same locations.
|
|
Tz
|
%s location mismatch:©r$ r´ rµ r¦ r )rÍ Úboolr r rg r Úndim) r ÚyÚfuncÚhasvalrj Úx_idÚy_idri r³ r´ rµ r¦ r$ s rL Úfunc_assert_same_posz2assert_array_compare.<locals>.func_assert_same_posö sÄ ø ð !ÐáAwÙAwô 7744<Ó × $Ñ $Ó &¨$Ò .Ü ØAØÐ3Øññ Ø$+°FØØ#ô %Cô ! Ó%Ð %ô dDÔ ! T§Y¡Y°!¢^Ü774=Ð Ü dÔ # t§y¡y°A¢~Ü774=Ð àKrK rJ z
|
(shapes z, z
|
mismatch)z
|
(dtypes r F)r r c ó | k( S ©NrJ ©Úxyr s rL rT z&assert_array_compare.<locals>.<lambda>6 ó ø ÀÀsÀdÁ
|
rK z+infc ó | k( S r rJ r s rL rT z&assert_array_compare.<locals>.<lambda>9 r! rK z-infÚNaTÚ na_objectrö ©rÏ r zMismatched elements: z / z (z.3gz%)ró )r ©ÚoutrÏ z*Max absolute difference among violations: z*Max relative difference among violations: r£ zerror during assertion:
|
|
z
|
|
),rË r r rù r r r r rÍ Ú
|
asanyarrayÚshaperÏ r rg r r r Úhasattrr r$ rø rf r ÚsizeÚ logical_notr ÚravelÚsumr Ú
|
contextlibÚsuppressrð Ú
|
issubdtypeÚunsignedintegerÚminimumÚgetattrr r© Ú logical_andÚ broadcast_tor° rÌ Ú tracebackÚ
|
format_exc)3Ú
|
comparisonr r r³ r$ r´ r¦ Ú equal_nanÚ equal_infr¼ rµ rj r r rù r r r ÚoxÚoyr r r r ÚcondÚreasonri ÚflaggedÚdtÚis_nanÚ bool_errorsrh ÚinvalidsÚreducedÚ
|
n_mismatchÚ
|
n_elementsÚpercent_mismatchÚremarksÚerrorÚerror2Ú reduced_errorÚ max_abs_errorÚnonzeroÚnonzero_and_invalidÚ max_rel_errorÚnonzero_invalid_errorÚ broadcasted_yÚnonzero_invalid_yr7 Úefmtr s3 ```` ` @rL r6 r6 á sÑ ý ð ÐßQ×QÑQä
|
aÓAÜ
|
aÓAð Bò6ò$ò#ð ).°e÷ %ñ %ðNI Ù Ø77aggÑ%Ò<¨!¯'©'°Q·W±WÑ*<DàGGrMÒ2 Q§W¡W°¡]ÒI°q·w±wÀ!Ç'Á'Ñ7IDÙØww!''Ò!Ø% a§g¡g Y¨b°·±° ¸ÐDà% a§g¡g Y¨b°·±° ¸ÐDÜ A Ø 'Ø"(ñ!)à(/¸Ø&+Ø*3ô 5Cô ! Ó%Ð %ä''%.Ù A;8 A;ÙÙ.¨q°!¸%ÈÔNâØÑ/°°1Û5JØ7=ô ?ñ ?ð Ñ/°°1Û5JØ7=ô ?ñ ?ñ AY6 !9áQWW\\¨Q¯W©W¯\©\Ò 9Ù.¨q°!¼%ÈÔNá q\i¨lØBÙR 1§7¡7]¬w°r¸;Ô/GÜ$ R§\¡\´5Ó9ò 1Ü (( 2§<¡<Ó0ð à ð$Ü Ô&ñ [á 2Ø1 5°·±×1BÑ1Bô DGð <<!Ò ØgX; 7 (¡ qAàvv{ØÙ à áAÓ Ü>> #Ó&ä c4Ô ØDÜSElGàiikGØ;;=Dð 4<Ø ¨¯ © ¼$¨ Ó(?Ñ?JØ)0¯ © ¸Ò): ÀÇ Á JØ " ZÑ /°*Ñ <Ð Ø.¨z¨l¸#¸j¸\ð JØ+¨CÐ0°ð4ð 5Gñ hÔ'ñ ) ;ä ×(Ñ(¬Ó3ñ ';Ü A¡JEÜ}} Q§W¡W¬b×.@Ñ.@ÔAÜ!$ Q¨¡U£Ü
|
|
5¨&°eÕ<à$)¨(¡OMÙ$'¨ Ó$6MÜ u g¨wÓ7¸7ÒBØ Ø HÜ ! -Ó 0ñ 1õ2ð Ø HÙ *¨=Ó 9ñ :ô;ô !gg a¨1¡foGÜ*,¯.©.¸À7Ó*KÐ'áÐ /Ð/Ô0Ü(-¨c«
|
à05Ð6IÑ0JÐ-Ü(*¯©¸¸5¿;¹;Ó(G Ø,9Ð:MÑ,NÐ)Ù(+Ð,AÜ.1Ð2CÓ.Dñ-Eó )F ô u g¨wÓ7¸7ÒBØ Ø HÜ ! -Ó 0ñ 1õ2ð Ø HÙ *¨=Ó 9ñ :ô;÷K';÷) ;ôT 'lGØ tdii¨Ó 0Ñ0Ñ 0GÜ R ¨'Ø(/¸Ø&+Ø*3ô5Cô ! Ó%Ð %ðo øô= !ò $Ø"#Kð$ú÷N';ð ';ú÷) ;ð ) ;ûôb ò ÛØ×#Ñ#Ó%Ø.¨t¨f°D¸¸ÐAäQ F G°WÀVØ"'°9ô>äoÐ ð úsr Á H V4 É+V
|
Ê AV4 ËV4 ËC V4 Î V(Î8FV Ô9V(ÕAV4 Ö
|
VÖV4 ÖVÖV4 Ö V% Ö!V(Ö(V1Ö-V4 Ö4AW8c óH d}t t j | |||d|¬« y)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.
|
|
.. note:: When either `actual` or `desired` is already an instance of
|
`numpy.ndarray` and `desired` is not a ``dict``, the behavior of
|
``assert_equal(actual, desired)`` is identical to the behavior of this
|
function. Otherwise, this function performs `np.asanyarray` on the
|
inputs before comparison, whereas `assert_equal` defines special
|
comparison rules for common Python types. For example, only
|
`assert_equal` can be used to compare nested Python lists. In new code,
|
consider using only `assert_equal`, explicitly converting either
|
`actual` or `desired` to arrays if the behavior of `assert_array_equal`
|
is desired.
|
|
Parameters
|
----------
|
actual : array_like
|
The actual object to check.
|
desired : 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 `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 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 among violations: 4.4408921e-16
|
Max relative difference among violations: 1.41357986e-16
|
ACTUAL: array([1. , 3.141593, nan])
|
DESIRED: 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)
|
ACTUAL: array([[3, 3, 3, 3, 3],
|
[3, 3, 3, 3, 3]])
|
DESIRED: 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)
|
ACTUAL: array([2, 2, 2])
|
DESIRED: array([2., 2., 2.], dtype=float32)
|
TzArrays are not equal)r³ r$ r´ r¼ N)r6 ÚoperatorÚ__eq__)rÔ rÕ r³ r$ r¼ rj s rL r r © s( ðv ÐÜ ¨&°'À7Ø!(Ð1GØ &ö(rK c óv
|
d}ddl m m
|
ddlm ddlm
|
fd}t || |||dz ¬« y )
|
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
|
----------
|
actual : array_like
|
The actual object to check.
|
desired : 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 among violations: 6.e-05
|
Max relative difference among violations: 2.57136612e-05
|
ACTUAL: array([1. , 2.33333, nan])
|
DESIRED: 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>
|
nan location mismatch:
|
ACTUAL: array([1. , 2.33333, nan])
|
DESIRED: array([1. , 2.33333, 5. ])
|
|
Tr )ÚnumberÚ result_type)Úany)r1 c ó t | « « s t |« « r]t | « }t |« }||k( j « sy| j |j cxk( rdk( rn n| |k( S | | } || }
|
|d« }t j ||« }t | |z
|
« } |j « s |j t
|
j « }|dd z z k S # t t f$ r Y |w xY w)NFrö g ð?rî rï ) r r r+ rf r rÍ r( rð rÏ Úastyperñ ) r r ÚxinfidÚyinfidrÏ Úzrì r1 ÚnpanyrY rZ s rL Úcomparez*assert_array_almost_equal.<locals>.compare} só ø ð ÙU1X¡%¬¨a«¤/Ü qÜ qØ &Ñ(×-Ñ-Ô/Ø à66QVVÔ( qÕ(Ø 6MØvgJØvgJñ ArÓ"Ü MM!UÓ #Ü AJá!'' 6Ô*ØÓ$Aà3 Ñ)Ñ)Ñ)Ð)øô Ô.Ð/ò Ù ð ús A C- Á&C- Á6 C- Ã-C?Ã>C?rë )r³ r$ r´ r¦ N)rË rY rZ Únumpy._core.fromnumericr[ Únumpy._core.numerictypesr1 r6 ) rÔ rÕ rì r³ r$ rj rb r1 ra rY rZ s ` @@@@rL r r * s? ü ð\ Ðß/Ý4Ý3÷*ð *ô4 &¨'¸7Ø!(ØAÀGÑKØ ö rK c óL d}t t j | |||dd|d¬« y)aJ
|
Raises an AssertionError if two array_like objects are not ordered by less
|
than.
|
|
Given two array_like objects `x` and `y`, check that the shape is equal and
|
all elements of `x` are strictly less than the corresponding elements of
|
`y` (but see the Notes for the special handling of a scalar). An exception
|
is raised at shape mismatch or values that are not correctly ordered. In
|
contrast to the standard usage in NumPy, 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.
|
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:: 2.0.0
|
|
Raises
|
------
|
AssertionError
|
If x is not strictly smaller than y, element-wise.
|
|
See Also
|
--------
|
assert_array_equal: tests objects for equality
|
assert_array_almost_equal: test objects for equality up to precision
|
|
Notes
|
-----
|
When one of `x` and `y` is a scalar and the other is array_like, the
|
function performs the comparison as though the scalar were broadcasted
|
to the shape of the array. This behaviour can be disabled with the `strict`
|
parameter.
|
|
Examples
|
--------
|
The following assertion passes because each finite element of `x` is
|
strictly less than the corresponding element of `y`, and the NaNs are in
|
corresponding locations.
|
|
>>> x = [1.0, 1.0, np.nan]
|
>>> y = [1.1, 2.0, np.nan]
|
>>> np.testing.assert_array_less(x, y)
|
|
The following assertion fails because the zeroth element of `x` is no
|
longer strictly less than the zeroth element of `y`.
|
|
>>> y[0] = 1
|
>>> np.testing.assert_array_less(x, y)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not strictly ordered `x < y`
|
<BLANKLINE>
|
Mismatched elements: 1 / 3 (33.3%)
|
Max absolute difference among violations: 0.
|
Max relative difference among violations: 0.
|
x: array([ 1., 1., nan])
|
y: array([ 1., 2., nan])
|
|
Here, `y` is a scalar, so each element of `x` is compared to `y`, and
|
the assertion passes.
|
|
>>> x = [1.0, 4.0]
|
>>> y = 5.0
|
>>> np.testing.assert_array_less(x, y)
|
|
However, with ``strict=True``, the assertion will fail because the shapes
|
do not match.
|
|
>>> np.testing.assert_array_less(x, y, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not strictly ordered `x < y`
|
<BLANKLINE>
|
(shapes (2,), () mismatch)
|
x: array([1., 4.])
|
y: array(5.)
|
|
With ``strict=True``, the assertion also fails if the dtypes of the two
|
arrays do not match.
|
|
>>> y = [5, 5]
|
>>> np.testing.assert_array_less(x, y, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Arrays are not strictly ordered `x < y`
|
<BLANKLINE>
|
(dtypes float64, int64 mismatch)
|
x: array([1., 4.])
|
y: array([5, 5])
|
Tz'Arrays are not strictly ordered `x < y`F)r r )r³ r$ r´ r; r¼ rµ N)r6 rV Ú__lt__)r r r³ r$ r¼ rj s rL r r s. ðT ÐÜ ¨!¨Q¸Ø!(Ø IØ#(Ø &Ø )ö +rK c ó t | |« y r )Úexec)ÚastrrÆ s rL r# r# s ÜtÕrK c ó, d}ddl }t | t « s t t t | « « « t |t « s t t t |« « « || k( ryt |j « j | j d« |j d« « « }g }|r-|j d« }|j d« r&|j d« rå|g}|j d« }|j d« r"|j |« |j d« }|j d« st t |« « |j |« |rF|j d« } | j d« r|j | « n|j d| « |dd |dd k( r |j |« t t |« « |syd d
|
j |« j! « }
|
| |k7 r t |
|
« y) 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:
|
ra )Údifflibr r© rg r® r rÈ ÚDifferrb r± ÚpopÚ
|
startswithr ÚinsertÚextendr° Úrstrip) rÔ rÕ rj rl ÚdiffÚ diff_listÚd1r Úd2Úd3ri s rL r r sÄ ð6 ÐÛä fcÔ "Ü T¤$ v£,Ó /Ó0Ð0Ü gsÔ #Ü T¤$ w£-Ó 0Ó1Ð1Ø&ÒØä Ó ×(Ñ(¨×):Ñ):¸4Ó)@Ø×"Ñ" 4Ó(ó*ó +DàIÚ
|
Ø XXa[Ø ==Ô Ø Ø ==Ô ØAØ!BØ}}TÔ"Ø ØXXa[Ø== Ô&Ü$¤T¨"£XÓ.Ð.Ø HHRLÙØXXa[Ø== Ô&ØHHRLàKK 2Ô&Ø!"vABÒ ÙØ × Ñ QÔ Ù Ü T "XÓ&Ð&Ù ØØ % b§g¡g¨iÓ&8×&?Ñ&?Ó&AÐ%BÐ
|
CCØ ÒÜ SÓ!Ð!ð rK c ó ddl }ddlm} | $t j d« }|j
|
d } t j j t j j | « « d } ||| « }|j « j |« }|j d¬« }g } |r | j }
|
nd}
|
|D ] } |j | |
|
¬« |j dkD r |r t! d d
|
j# | « z « yy) aX
|
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 N)Úexec_mod_from_locationrö Ú__file__FrÄ r& zSome doctests failed:
|
%sr£ )ÚdoctestÚnumpy.distutils.misc_utilry ÚsysÚ _getframeÚ f_globalsr r} ÚsplitextÚbasenameÚ DocTestFinderrª Ú DocTestRunnerr ÚrunÚfailuresrg r° ) ÚfilenameÚraise_on_errorr{ ry r r^ ÚmÚtestsÚrunnerri r' Útests rL r" r" [ sò ó, å@ØÐÜ MM!Ó Ø;;zÑ*Ü 77× Ñ BGG× ,Ñ ,¨XÓ 6Ó 7¸Ñ :DÙ t XÓ.Aà × !Ñ !Ó #× (Ñ (¨Ó +EØ × "Ñ "¨5Ð "Ó 1Fà
|
CÙØjjààò "Ø
|
|
4S
|
Õ!ð"ð Ò~Ü Ð 8¸4¿9¹9ÀS»>Ñ IÓJÐJð .ÐrK c óÈ | r| d S ddl }d} |j |dd¬« }d|j v }| j |« | d S # t |j f$ r d}Y /w xY w)z
|
gh-22982
|
r NÚlscpuT)Úcapture_outputÚtextÚsveF)Ú
|
subprocessr ÚstdoutÚOSErrorÚSubprocessErrorr )Ú__cacher ÚcmdÚoutputÚresults rL r< r< sy ñ
|
ØqzÐãØ
|
CðØ °D¸t ÓDØ&--Ð'ð NN6ÔØ 1:Ðøô Z×/Ñ/Ð 0ò Øðús "A ÁA!Á A!c ó e Zd Zd Zy)Ú_Dummyc ó y r rJ )Úselfs rL Únopz
|
_Dummy.nop¤ s Ø rK N)rF rG rH r rJ rK rL r r £ s ó rK r r c ó0 d}t j | i |¤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Ó Úkwargsrj s rL r r « s ð2 ÐÜ ??DÐ + FÑ +Ð+rK c ó: d}t j | |g|¢i |¤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`.
|
T)r ÚassertRaisesRegex)Úexception_classÚexpected_regexprÓ r¡ rj s rL r( r( È s' ð ÐÜ × Ñ ° Ð RÀ4Ò RÈ6Ñ RÐRrK c óà |'t j dt j z « }nt j |« }| j }ddlm} |j « D cg c] } ||« s | }}|D ]_ } t |d« r |j }n |j }|j |« s;|j d« rMt | | ||« « a yc c}w # t $ r Y sw xY w)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 )Ú
|
isfunctionÚcompat_func_nameÚ_)ÚreÚcompiler ÚsepÚ__dict__Úinspectr§ Úvaluesr* r¨ rF ÚAttributeErrorÚsearchro Úsetattr) ÚclsÚ decoratorÚ testmatchÚcls_attrr§ Ú_mÚmethodsÚfunctionÚfuncnames rL r r Ø sÛ ð. ÐÜJJÐ ;¼b¿f¹fÑ DÓE äJJyÓ) Ø||Hõ #à $OOÓ -Ö@b±¸Bµ rÐ@GÐ@Øò
|
8ð ÜxÐ!3Ô4Ø#×4Ñ4à#×,Ñ,ð × Ñ HÕ %¨h×.AÑ.AÀ#Õ.FÜ C¡9¨XÓ#6Õ 7ñ
|
8ùò Aøô ò á ð ús Á# C Á1C Á=%C!Ã! C-Ã,C-c óô t j d« }|j |j }}t | d| dd« }d}t « }||k r|dz }t |||« ||k rt « |z
|
}d|z 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
|
|
rö z Test name: r rh r g{®Gáz?)r} r~ Úf_localsr r« r rh ) Úcode_strÚtimesÚlabelÚframeÚlocsÚglobsÚcoder¶ Úelapseds rL r% r% s ôB MM!Ó EØ.. %§/¡/%Dä 8{¨5¨'°Ð 3°VÓ <DØ AÜiGØ
|
e)Ø QÜ T5$Ô ð e)ô i'Ñ!GØ '>ÐrK c ó~ t syddl}ddl} |j d« j dd« }|}d} |j
|
« t j |« }t d« D ] } | ||« } t t j |« |k\ « |j « y# |j « w xY w)zg
|
Check that ufuncs don't mishandle refcount of object `1`.
|
Used in a few regression tests.
|
Tr Ni' r rö é ) r3 ÚgcrM r ÚreshapeÚdisabler} rZ rÊ r& Úenable) ÚoprÇ rÍ ÚbÚcr¶ ÚrcÚjÚds rL Ú_assert_valid_refcountrÑ 4 s õ
|
Øã ãà )Ó ×$Ñ$ S¨#Ó.AØ AØ AàBJJLðÜ __QÓ Ürò AÙ1aAð ä Ó" bÑ(Ô)à ø ús ÁAB) Â)B<c
|
ó¼ d}ddl fd} j | « j |« }} dddd}
|
t | | |t |« ||
|
|¬« y) u÷
|
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)``.
|
|
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.
|
strict : bool, optional
|
If True, raise an ``AssertionError`` when either the shape or the data
|
type of the arguments does not match. The special handling of scalars
|
mentioned in the Notes section is disabled.
|
|
.. versionadded:: 2.0.0
|
|
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 performs the comparison as if the scalar were
|
broadcasted to the shape of the array.
|
This behaviour can be disabled with the `strict` parameter.
|
|
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)
|
|
As mentioned in the Notes section, `assert_allclose` has special
|
handling for scalars. Here, the test checks that the value of `numpy.sin`
|
is nearly zero at integer multiples of Ï.
|
|
>>> x = np.arange(3) * np.pi
|
>>> np.testing.assert_allclose(np.sin(x), 0, atol=1e-15)
|
|
Use `strict` to raise an ``AssertionError`` when comparing an array
|
with one or more dimensions against a scalar.
|
|
>>> np.testing.assert_allclose(np.sin(x), 0, atol=1e-15, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Not equal to tolerance rtol=1e-07, atol=1e-15
|
<BLANKLINE>
|
(shapes (3,), () mismatch)
|
ACTUAL: array([ 0.000000e+00, 1.224647e-16, -2.449294e-16])
|
DESIRED: array(0)
|
|
The `strict` parameter also ensures that the array data types match:
|
|
>>> y = np.zeros(3, dtype=np.float32)
|
>>> np.testing.assert_allclose(np.sin(x), y, atol=1e-15, strict=True)
|
Traceback (most recent call last):
|
...
|
AssertionError:
|
Not equal to tolerance rtol=1e-07, atol=1e-15
|
<BLANKLINE>
|
(dtypes float64, float32 mismatch)
|
ACTUAL: array([ 0.000000e+00, 1.224647e-16, -2.449294e-16])
|
DESIRED: array([0., 0., 0.], dtype=float32)
|
|
Tr Nc óX j j j | |¬« S )N)ÚrtolÚatolr: )Ú_coreÚnumericÚisclose)r r rÕ r: rÍ rÔ s rL rb z assert_allclose.<locals>.compare° s0 ø Øxx× Ñ ×'Ñ'¨¨1°4¸dØ1:ð (ó <ð <rK z Not equal to tolerance rtol=Úgz, atol=)r³ r$ r´ r: r¼ )rM r( r6 r© ) rÔ rÕ rÔ rÕ r: r³ r$ r¼ rj rb r´ rÍ s ``` @rL r, r, N si û ð~ ÐÛ÷<ð $bmm FÓ+¨]¨R¯]©]¸7Ó-CGFØ+¨D°¨8°7¸4À¸(Ð CFÜ &¨'¼3¸w»<Ø!(°À9Ø &ö(rK c óÈ d}ddl } |j | « } |j |« }| |j |j ||kD ||« « z } |j |j | |z
|
« |k « sf |j
|
| « s |j
|
|« rd| d}t |« |j t | |« « } d| d| dd}t |« y) 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: Arrays are not equal to 1 ULP (max is 2)
|
|
Tr NzArrays are not equal to z ULPz ULP (max is rÙ ú)) rM rð ÚspacingÚwherer rÀ r Ú nulp_diffrg )
|
r r Únulprj rÍ ÚaxÚayÚrefri Úmax_nulps
|
rL r' r' » sé ðb ÐÛØ BØ BØ
|
HBHH R¨"¡W¨b°"Ó 5Ó6Ñ
|
6CØ 266&"&&Q- 3Ñ&Ô 'Ø 2??1Ô § ¡ °Ô!3Ø,¨T¨F°$Ð7Cô SÓ!Ð!ð rvvi¨¨1oÓ.HØ,¨T¨F°-Àȸ|È1ÐMCÜ SÓ!Ð!ð (rK c ó d}ddl }t | ||« } |j ||k « s t d| |j |« fz « |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))rM rÞ r rg r )r· rÌ ÚmaxulprÏ rj rÍ Úrets rL r) r) ú s^ ðT ÐÛÜ
|
Aq%Ó
|
CØ 266#-Ô Ü ð >à $ f b§f¡f¨S£kÐ 2ñ 3ó 4ð 4ð JrK c óÄ ddl |r) j | |¬« } j ||¬« }n$ j | « } j |« } j | |« } j | « s j |« r t d« j
|
| g|¬« } j
|
|g|¬« }j | j | « < j | j |« < | j |j k( s%t d| j d|j « fd}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#Arrays do not have the same shape: z - c óV j | |z
|
|¬« } j |« S ©Nr% )rÎ rð )ÚrxÚryÚvdtrs rÍ s rL Ú_diffznulp_diff.<locals>._diffc s) ø Ørzz"r'¨Ô-Ørvvd|ÐrK ) rM rÎ Ú common_typerÀ r r r r r) rÌ Ú integer_repr)r r rÏ Útrí rê rë rÍ s @rL rÞ rÞ . s6 ø ó@ Ù Ø BJJq Ô &Ø BJJq Ô &à BJJqMØ BJJqMàq!Ó AØrqÔ_R__¨QÔ /Ü!Ð"KÓLÐLà!AÔ AØ!AÔ AàVVAhbhhqkNØVVAhbhhqkNà 77aggÒ ÜÐ>¸q¿w¹w¸iÀsÈ1Ï7É7È)ÐTÓUÐUô ô
|
a BÜ a BÙ RÓ ÐrK c ó | j |« }|j dk( s|||dk z
|
||dk < |S |dk r||z
|
}|S )Nrö r )Úviewr+ )r rì Úcomprê s rL Ú _integer_reprrô l sT ð
|
|
BØ GGqLØBr AvJÑ&26
|
ð Ið
|
aØ BYà IrK c óº ddl }| j |j k( r't | |j |j d« « S | j |j
|
k( r't | |j |j d« « S | j |j k( r't | |j |j d« « S t d| j « )zQReturn the signed-magnitude interpretation of the binary representation
|
of x.r Ni ÿÿi lûÿÿÿ zUnsupported dtype )
|
rM rÏ Úfloat16rô Úint16r Úint32rñ Úint64rÌ )r rÍ s rL rï rï z s¨ ó Øww"**Ò Ü Q §¡¨(¨"¯(©(°6Ó*:Ó;Ð;Ø
|
BJJÒ Ü Q §¡¨(¨"¯(©(°6Ó*:Ó;Ð;Ø
|
BJJÒ Ü Q §¡¨(¨"¯(©(°6Ó*:Ó;Ð;äÐ-¨a¯g©g¨YÐ7Ó8Ð8rK c # óÄ K d}t « 5 }|j | « }d t |« dkD s|d| nd}t d|z « d d d « y # 1 sw Y y xY ww)NTr ú when calling ra zNo warning raised)r5 Úrecordr« rg )Ú warning_classr^ rj Úsupr Úname_strs rL Ú_assert_warns_contextr sq è ø à ÐÜ Ó ð A Ø JJ}Ó %Û Ü1vzØ26Ð2B ¨ vÑ.ÈHÜ Ð!4°xÑ!?Ó@Ð @ð ÷A÷ Añ Aüs A ;AÁ A ÁA ÁA c óî |s |s t | « S t |« dk rd|v r t d« t d« |d }|dd }t | |j ¬« 5 ||i |¤cddd« S # 1 sw Y yxY w)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.
|
|
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ö ÚmatchzAassert_warns does not use 'match' kwarg, use pytest.warns insteadz(assert_warns(...) needs at least one argr N©r^ )r r« Ú RuntimeErrorrF )rý rÓ r¡ r s rL r* r* s ñV Ü$ ]Ó3Ð3Ü TQ Ø fÑ Ü ð+óð ô ÐEÓFÐFà 7DØ 8DÜ }°4·=±=Ô Añ %ÙTÐ$VÑ$÷%÷ %ò %ús ÁA+Á+A4c # óê K d}t j d¬« 5 }t j d« d t |« dkD r| d| nd}t d| d| « d d d « y # 1 sw Y y xY ww) NT©rü Úalwaysr rû ra z Got warningsr¨ )ÚwarningsÚcatch_warningsÚ simplefilterr« rg )r^ rj r rÿ s rL Ú_assert_no_warnings_contextr Î s è ø à ÐÜ × Ñ ¨Ô -ð A°Ü× Ñ hÔ'Û Ü q6A:Ø26Ð2B ¨ vÑ.ÈHÜ <°¨z¸¸A¸3Ð!?Ó@Ð @ð ÷A÷ Añ Aüs A3AA'Á A3Á'A0Á,A3c ó | s
|
t « S | d }| dd } t |j ¬« 5 || i |¤cddd« S # 1 sw Y yxY w)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.
|
|
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 rö Nr )r rF ©rÓ r¡ r s rL r+ r+ Ù sR ñ2 Ü*Ó,Ð,à 7DØ 8DÜ $¨$¯-©-Ô 8ñ %ÙTÐ$VÑ$÷%÷ %ò %ús ?¿AÚbinaryé c # ó0
|
K d}d}t d« D ]|
|
t
|
dz t
|
dz |« « D ]Y |dk( rÌ
|
fd}t f ¬«
|
d }| |« |
|
|
d fz f |« }|||
|
|
d
|
fz f |d d |« dd |
|
d z
|
d z
|
d fz f |dd |« d d |
|
|
d z d z
|
d fz f |« dd |« d d |
|
|
d z d z
|
d fz f |« d d |« dd |
|
d z
|
d z
|
d fz f |dk( sÛ
|
fd}
|
fd} t f ¬«
|
d }| |« | « |
|
|
|
d fz f |« }|| | « |
|
|
|
dfz f | « }| |« ||
|
|
|
dfz f |d d |« dd | « dd |
|
d z
|
|
d z
|
d fz f |dd |« d d | « dd |
|
|
d z
|
d z
|
d fz f |dd |« dd | « d d |
|
|
|
d z d z
|
d fz f |« d d |« dd | « dd |
|
d z
|
|
d z
|
d fz f |« dd |« d d | « dd |
|
|
d z
|
d z
|
d fz f |« dd |« dd | « d d |
|
|
|
d z d z
|
d fz f \ yw)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, %srN rk Úunaryc ó$ t ¬« d S ré ©r ©rÏ ÚoÚss rL rT z%_gen_alignment_data.<locals>.<lambda> s ø f Q¨eÔ 4°Q°RÐ 8 rK r% Nz out of placezin placerö r¤ Úaliasedr c ó$ t ¬« d S ré r r s rL rT z%_gen_alignment_data.<locals>.<lambda>' ó ø v a¨uÔ 5°a°bÐ 9 rK c ó$ t ¬« d S ré r r s rL rT z%_gen_alignment_data.<locals>.<lambda>( r rK z in place1z in place2)rÊ r r ) rÏ r Úmax_sizeÚufmtÚbfmtÚinpr' rÐ Úinp1Úinp2r r s ` @@rL Ú_gen_alignment_datar! û s úè ø ð2 :DØ >DÜ 1Xó ';Üq1uc ! a¡%¨Ó 2Ó3ó & ;AØwÝ8ÜQD¨Ô.¨q¨rÐ2Ø35 $¨!¨Q°°5¸.Ð)IÑ"IÐIÒIÙEØD A q¨!¨U°JÐ#?Ñ ?Ð?Ò?Ø!"gsu S bz¨4ØUAq 1u e¨^Ð<ñ,=ð =ò =à#2h¡£ a b ¨4ØAq 1u e¨^Ð<ñ,=ð =ò =áeCRj¡#£%¨¨ )¨TØAq 1u e¨YÐ7ñ.8ð 8ò 8áeABi¡£ s¨ ¨TØUAq 1u e¨YÐ7ñ.8ð 8ò 8àxÓ Ý9Ý9ÜQD¨Ô.¨q¨rÐ2Ø46¡4£6¨4Ø1a ¨Ð7ñ,8ð 8ò 8áFØDF DØ1a ¨ Ð4ñ%5ð 5ò 5áFØ DØ1a ¨ Ð4ñ%5ð 5ò 5à!"gtv c r{©D«F°3°B¨K¸ØUAq ! a¡%¨°Ð?ñ:@ð @ò @à#2h¡£ q r
|
©D«F°3°B¨K¸ØAq ! a¡%¨°Ð?ñ:@ð @ò @à#2h¡£ s¨ ©T«V°A°B¨Z¸Ø1q5 ! a¡%¨°Ð?ñ:@ð @ò @áfQRj¡$£&¨¨" +©t«v°c°r¨{¸DØUAq ! a¡%¨° Ð:ñ=;ð ;ò ;áfSbk¡4£6¨!¨" :©t«v°c°r¨{¸DØAq ! a¡%¨° Ð:ñ=;ð ;ò ;áfSbk¡4£6¨#¨2 ;±³°q°r°
|
¸DØ1q5 ! a¡%¨° Ð:ñ=;ð ;ô ;òK& ;ñ';ùs
D
|
JÄFJc ó e Zd ZdZy)r- z/Ignoring this exception due to disabled featureNrE rJ rK rL r- r- @ s Ù5ØrK r- c / ó K t | i |¤} | t j |« y# t j |« w xY ww)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¡ Útmpdirs rL r1 r1 E s9 è ø ô dÐ %fÑ %Fð Ø ä fÕ ø fÕ üs A) A©A Á Ac / óº K t | i |¤\ }}t j |« | t j |« y# t j |« w xY ww)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¡ Úfdr} s rL r0 r0 T sF è ø ô Ð' Ñ'HBÜHHRLðØ
|
ä
|
$ø $üs $A§A «AÁAÁAc ó< e Zd ZdZdZd fd Z fdZ fdZ xZS )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, 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
|
rJ c ó t |« j | j « | _ i | _ t
|
| |¬« y )Nr )ÚsetÚunionÚ class_modulesÚmodulesÚ_warnreg_copiesÚsuperÚ__init__)r rü r0 Ú __class__s rL r3 z!clear_and_catch_warnings.__init__ s7 ø Ü7|×)Ñ)¨$×*<Ñ*<Ó= Ø !Ô Ü Ñ ÐÕ'rK c óÎ | j D ]H }t |d« s|j }|j « | j |< |j « J t | « S ©NÚ__warningregistry__)r0 r* r7 Úcopyr1 Úclearr2 Ú __enter__)r ÚmodÚmod_regr4 s rL r: z"clear_and_catch_warnings.__enter__ s[ ø Ø<<ò CÜsÐ 1Õ2Ø ×1Ñ1Ø,3¯L©L«N×$Ñ$ SÑ)Ø ð ô
|
wÑ Ó"Ð"rK c óú t | | | j D ]_ }t |d« r|j j « || j v s8|j j | j | « a y r6 )r2 Ú__exit__r0 r* r7 r9 r1 Úupdate)r Úexc_infor; r4 s rL r> z!clear_and_catch_warnings.__exit__£ so ø Ü Ñ(Ñ#Ø<<ò JCÜsÐ 1Ô2Ø×'Ñ'×-Ñ-Ô/Ød×*Ñ*Ò*Ø×'Ñ'×.Ñ.¨t×/CÑ/CÀCÑ/HÕIñ JrK )FrJ ) rF rG rH rI r/ r3 r: r> Ú __classcell__)r4 s @rL r. r. j s& ø ñ(ðR Mõ(ô
|
#÷Jð JrK r. c óh e Zd ZdZddZd ZedddfdZeddfdZeddfd Z d
|
Z
|
d Z dd d Z d Z y)r5 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
|
c óL d| _ g | _ |dvr t d« || _ y )NF> Úoncer ÚmoduleÚlocationz unsupported forwarding rule.)Ú_enteredÚ _suppressionsrÌ Ú_forwarding_rule)r Úforwarding_rules rL r3 zsuppress_warnings.__init__ö s0 Ø ð Ôà Ð"JÑ JÜ Ð ;Ó<Ð <Ø /Õ rK c ó¾ t t d« rt j « y | j D ]) }t |d« s|j j « + y )NÚ_filters_mutatedr7 )r* r rL Ú _tmp_modulesr7 r9 )r rE s rL Ú_clear_registriesz#suppress_warnings._clear_registries sR Ü 8Ð /Ô 0ô × %Ñ %Ô 'Ø ð ×'Ñ'ò 3FÜvÐ 4Õ5Ø×*Ñ*×0Ñ0Õ2ñ 3rK ra NFc ó4 |rg }nd }| j rÂ|t j d||¬« nc|j j dd« dz }t j d|||¬« | j
|
j |« | j « | j j ||t j |t j « ||f« |S | j j ||t j |t j « ||f« |S )Nr ©ÚcategoryÚmessageú.ú\.ú$©rQ rR rE )rG r ÚfilterwarningsrF ÚreplacerM ÚaddrN Ú_tmp_suppressionsr rª r« ÚIrH )r rQ rR rE rü Ú module_regexs rL Ú_filterzsuppress_warnings._filter sü Ù ØFàFØ ==Ø~Ü×'Ñ'Ø x¸öBð &× 6Ñ 6°s¸EÓ BÀSÑ H Ü×'Ñ'Ø x¸Ø'õ)ð ×!Ñ!×%Ñ% fÔ-Ø×&Ñ&Ô(à × "Ñ "× )Ñ )Ø7¤B§J¡J¨w¼¿¹Ó$=¸vÀvÐNô Pð ð × Ñ × %Ñ %Ø7¤B§J¡J¨w¼¿¹Ó$=¸vÀvÐNô Pð rK c ó. | j |||d¬« y)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©rQ rR rE rü N©r] ©r rQ rR rE s rL Úfilterzsuppress_warnings.filter% s ð( h°ÀØ !ð õ #rK c ó, | j |||d¬« S )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` ra s rL rü zsuppress_warnings.record< s# ð6 || X°wÀvØ#'ð ó )ð )rK c ó | j r t d« t j | _ t j
|
| _ | j d d t _ d| _ g | _ t « | _ t « | _
|
g | _ | j D ]} \ }}}}}||d d
= |t j d||¬« +|j j dd« dz }t j d|||¬« | j j! |« | j" t _ | j% « | S ) Nz%cannot enter suppress_warnings twice.Tr rP rS rT rU rV )rG r r Ú showwarningÚ
|
_orig_showÚfiltersÚ_filtersrZ r- rM Ú
|
_forwardedÚlogrH rW rF rX rY Ú _showwarningrN )r ÚcatÚmessr© r; rj r\ s rL r: zsuppress_warnings.__enter__Z s Ø ==Ü Ð FÓGÐ Gä"×.Ñ.Ü ×(Ñ( Ø ==©Ð+Ôà Ø!#Ô Ü EÔÜ %àà&*×&8Ñ&8ò +Ñ "Cq#sØØFØ{Ü×'Ñ'Ø s°Dö:ð #||× 3Ñ 3°C¸Ó ?À#Ñ E Ü×'Ñ'Ø s°DØ'õ)ð ×!Ñ!×%Ñ% cÕ*ð +ð $× 0Ñ 0Ô Ø × Ñ Ô à rK c ó | j t _ | j t _ | j « d| _ | ` | `y )NF)rf r re rh rg rN rG )r r@ s rL r> zsuppress_warnings.__exit__z s7 Ø #Ô Ø ==ÔØ × Ñ Ô Ø Ø OØ MrK )Ú use_warnmsgc óÆ | j | j z d d d
D ]Ï \ }} }
|
} } t ||« s|
|
j |j d « 5| ?| ;t ||||fi |¤} | j j | « | j | « y | j j |« s| ;t ||||fi |¤} | j j | « | j | « y | j dk( r.| | j ||||g|¢i |¤ y | j |« y | j dk( r|j |f}n>| j dk( r|j ||f}n | j dk( r|j |||f}| j v ry | j j |« | | j ||||g|¢i |¤ y | j |« y )Nr¤ r r rD rE rF )rH rZ Ú
|
issubclassr rÓ r rj r rz ro rI rf Ú _orig_showmsgri rY )r rR rQ r Úlinenoro rÓ r¡ rl r© Úpatternr; Úrecri Ú signatures rL rk z suppress_warnings._showwarning sû ð ×"Ñ" T×%;Ñ%;Ñ;¹T¸r¸Tñ*Cò Ñ %CGS #ä8 SÕ)ØMM '§,¡,¨q¡/Ó2Ñ>Ø;àÜ ,¨W°hÀØ-3ñ ?Ø7=ñ ?à ¨Ô,Ø
|
|
3Ùð \\×,Ñ,¨XÕ6àÜ ,¨W°hÀØ-3ñ ?Ø7=ñ ?à ¨Ô,Ø
|
|
3Ùð+ ð2 × Ñ HÒ ,ØÐ"Ø ¨°8¸Vð 1Ø!%ò1Ø)/ò1ð ð ×"Ñ" ;Ô/Ø à × Ñ FÒ *Ø xÐ0IØ × "Ñ " hÒ .Ø x°Ð:IØ × "Ñ " jÒ 0Ø x°¸6ÐBIà Ñ 'Ø Ø ×ÑIÔ&Ø Ð Ø DOOG X¨x¸ð &À$ò &Ø $ó &ð × Ñ {Õ +rK c ó2 t « fd« }|S )z_
|
Function decorator to apply certain suppressions to a whole
|
function.
|
c óD 5 | i |¤cd d d « S # 1 sw Y y xY wr rJ )rÓ r¡ r r s rL Únew_funcz,suppress_warnings.__call__.<locals>.new_funcº s( ø àñ -ÙTÐ, VÑ,÷ -÷ -ò -ús ©r )r r ry s `` rL Ú__call__zsuppress_warnings.__call__µ s" ù ô
|
|
tô -ó
|
ð -ð rK )r )rF rG rH rI r3 rN ÚWarningr] rb rü r: r> rk r{ rJ rK rL r5 r5 ¬ sZ ñHóR0ò
|
3ð '°¸4Èó ð2 &¨r¸$ó #ð. &¨r¸$ó )ò< ò@ð )-ô1,óf
|
rK r5 c # ó> K d}t sd y t t j « « t j « t j
|
« } t d« D ] }t j « dk( s n t d« t j t j « d t j « }t j d d }t j d d
= t j |« t j « |rE| d| nd}t dj ||t |« dj! d |D « « « « y # t j d d
= t j |« t j « w xY ww) NTr r z]Unable to fully collect garbage - perhaps a __del__ method is creating more reference cycles?rû ra zXReference cycles were found{}: {} objects were collected, of which {} are shown below:{}c 3 óÀ K | ]V }d j t |« j t |« t j
|
|« j dd« « X yw)z
|
{} object with id={}:
|
{}r£ z
|
N)r{ r rF Úidrå ÚpformatrX )Ú.0r s rL ú <genexpr>z/_assert_no_gc_cycles_context.<locals>.<genexpr>ë sR è ø ò ð
|
ð 8×>Ñ>Ü Q×(Ñ(Ü1Ü qÓ)×1Ñ1°$¸ÓA÷ñùs A A )r3 r& rÇ Ú isenabledrÉ Ú get_debugrÊ Úcollectr Ú set_debugÚ DEBUG_SAVEALLÚgarbagerÊ rg r{ r« r° )r^ rj Úgc_debugr¶ Ún_objects_in_cyclesÚobjects_in_cyclesrÿ s rL Ú _assert_no_gc_cycles_contextr  sM è ø à Ðõ Û Øä BLLNÔÜJJLÜ||~HðÜsò 6AÜzz|qÓ Ùð 6ô ð5ó6ð 6ô R×%Ñ%Ô&Û ô !jjlÐÜ JJ¡qMÐä JJqMÜ
|
XÔ Ü
|
áØ.2Ð.>^ D 6Ñ*ÀBÜ ð -ç VØØ#ÜÐ%Ó&Øñ ð
|
1ô ó ó ó
|
ð
|
ð øô JJqMÜ
|
XÔ Ü
|
üs& AF Á%E Á<A E ÃBF Å >FÆF c ó | s
|
t « S | d }| dd } t |j ¬« 5 || i |¤ ddd« y# 1 sw Y yxY w)a
|
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()
|
|
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 rö Nr )r rF r s rL r7 r7 ö sR ñ0 Ü+Ó-Ð-à 7DØ 8DÜ %¨4¯=©=Ô 9ñ Ù dÐ fÒ ÷ ÷ ñ ús ?¿Ac óÚ t j « t rQt j « t j « t j « t j « yy)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
r2 rJ rK rL r8 r8
|
s9 ô JJLÝä
|
|
|
Ü
|
|
|
Ü
|
|
|
Ü
|
|
|
ð rK c ó ddl fd}|S )z:Decorator to skip a test if not enough memory is availabler Nc ó4 t « fd« }|S )Nc ó t « }|j |« | i |¤S # t $ r j d« Y y w xY w)NzMemoryError raised)Úcheck_free_memoryÚskipÚ MemoryErrorÚxfail)r· Úkwri Ú
|
free_bytesr Úpytests rL Úwrapperz3requires_memory.<locals>.decorator.<locals>.wrapper.
|
sM ø ä# JÓ/CØØ CÔ ð 3ÙQ~ "~Ð%øÜ ò 3à Ð 1Ö2ð 3ús ¡) ©AÁArz )r r r r s ` rL r´ z"requires_memory.<locals>.decorator-
|
s ù Ü tõ 3ó
|
ð 3ð rK )r )r r´ r s ` @rL Úrequires_memoryr )
|
s ù ãõ ð ÐrK c ó d}t j j |« }| t |« }| dz d| d}n#t « }|d}d }n| dz }|dz }| d
|
| d }|| k r|S dS # t $ r}t d| d| « d}~ww xY w) z
|
Check whether `free_bytes` amount of memory is currently free.
|
Returns: None if enough memory available, otherwise error message
|
ÚNPY_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.r¤ z GB memory required, but z GB available)r ÚenvironÚgetÚ _parse_sizerÌ Ú_get_mem_available)r Úenv_varÚ env_valueÚmem_freerº ri Ú free_bytes_gbÚ mem_free_gbs rL r r ?
|
sÔ ð
|
"GÜ
|
|
wÓ'IØÐ ð OÜ" 9Ó-Hð sÑ"Ð#ð $$Ø$- ;¨dð4ô &Ó'à Ð ð Cð Hà &¨Ñ ,MØ" S.KØ"OÐ#<¸[¸MÈ ÐWCàZÒ'3Ð1¨TÐ1øô% ò OÜ Ð <¸W¸IÀRÈÀuÐ MÓNÐ Nûð Oús ¥ A( Á( BÁ1BÂBc ó¨ dddddddddddddd d
|
}d j |j « « }t j d | d t j « }|j | j « « }|r|j d« |vrt d| d« t t |j d« « ||j d« z « S )z3Convert memory size strings ('12 GB' etc.) to floatrö iè i@B i Ê;l J)£é i i @l )ra rÌ rÖ r rÙ rð ÚkbÚmbÚgbÚtbÚkibÚmibÚgibÚtibú|z^\s*(\d+|\d+\.\d+)\s*(z)\s*$rk zvalue z not a valid size) r° Úkeysrª r« r[ r ÚlowerÚgrouprÌ r rø )Úsize_strÚsuffixesÚ pipe_suffixesÚsize_rer s rL r r ^
|
sÄ àAØ ¨g¸GØ '°ÀØ G°GÀGñMHð
|
HHX]]_Ó-MäjjÐ 2°=°/ÀÐGÌÏÉÓNGà hnnÓ&Ó'AÙ
|
(Ñ*Ü6 ( Ð->Ð?Ó@Ð@Ü uQWWQZÓ 8¨A¯G©G°A«JÑ#7Ñ7Ó 8Ð8rK c ó° ddl } | j « j S # t t f$ r Y nw xY wt
|
j j d« ri }t d« 5 }|D ]F }|j « }t |d « dz ||d j d« j « < H ddd« n # 1 sw Y nxY wd|v r|d S |d |d
|
z S y) z5Return available memory in bytes, or None if unknown.r Nr z /proc/meminforö r§ ú:Ú memavailableÚmemfreeÚcached) ÚpsutilÚvirtual_memoryÚ availableÚ ImportErrorr° r} Úplatformro r r r Ústripr² )r½ Úinfor ÚlineÚps rL r r o
|
så ð ÛØ×$Ñ$Ó&×0Ñ0Ð0øÜ Ð (ò Ù ð úô ||× Ñ wÔ'ØÜ /Ó "ð A aØò AØJJLÜ03°A°a±D³ ¸DÑ0@QqTZZ _×*Ñ*Ó,Ò-ñ A÷ A÷ Añ Aúð
|
TÑ !àÑ'Ð 'à ? T¨(¡^Ñ3Ð 3à s 2±2Á!A B7Â7C c óR t t d« s S t « fd« }|S )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 óÆ t j « } t j d « | i |¤t j |« S # t j |« w xY wr )r} rÇ Úsettrace)rÓ r¡ Úoriginal_tracer s rL r z _no_tracing.<locals>.wrapper
|
sE ø ä \\^Nð -Ü TÔ"ÙTÐ, VÑ,ä ^Õ,ø ^Õ,ús A Á A )r* r} r )r r s ` rL Ú _no_tracingrË
|
s1 ø ô 3
|
Ô #Ø ä tó -ó
|
ð -ð rK c óz t j d« j d« d } | S # t $ r d} Y | S w xY w)NÚCS_GNU_LIBC_VERSIONr rö ú0.0)r ÚconfstrÚrsplitr )Úvers rL Ú_get_glibc_versionrÒ
|
sH ðÜjjÐ.Ó/×6Ñ6°sÓ;¸AÑ>ð Jøô ò Øà Jðús '+ « :¹:c ó* t dk7 xr t | k S )NrÎ )Ú _glibcverr
|
s rL rT rT ¥
|
s y¨EÑ 1Ò C´iÀ!±m rK c
|
óú t |« D ]ý }t j j |¬« 5 }|g }n |« }|r&t j
|
|« } |j | « |r t |« D
|
cg c] }
|
| |
|
g|¢ } }
|
n t |« D
|
cg c] }
|
| g|¢
|
} }
|
g } | D ] } | j |j | « " t « |k r|r j « | D ] }|j « ddd« ÿ yc c}
|
w c c}
|
w # t $ r&}ddl }|j d| d|d« Y d}~xd}~ww xY w# t « |k r|r j « w w w xY w# 1 sw Y nxY w)z&Runs a function many times in parallel)Ú max_workersNr z Spawning z threads failed with error z@ (likely due to resource limits on the system running the tests))rÊ Ú
|
concurrentÚfuturesÚThreadPoolExecutorÚ threadingÚBarrierr Úsubmitr r r r« Úabortr )r rÖ Ú
|
pass_countÚ pass_barrierÚouter_iterationsÚ prepare_argsr© ÚtperÓ Úbarrierr¶ Úall_argsrØ Úargrã r r s rL rA rA ¨
|
s ô Ð#Ó $ò Ü× Ñ ×3Ñ3À Ð3ÓLð ØØÐ#Øá#~ÙÜ#×+Ñ+¨KÓ8Ø GÔ$ÙÜ6;¸KÓ6HÖI°T 1Ð , tÓ ,ÐIÑIä38¸Ó3EÖF¨aTM DMÐFÐFð $Ø Ø#ò 5CØNN : 3§:¡:¨sÐ#3Õ4ñ5ô w< +Ò-±,ØMMOØ ò Ø
|
ñ ÷3 ð ñùò JùâFøô
|
ò 9Û Ø i¨ }ð 5%Ø%& Eð *8ð 8÷ 9ñ 9ûð 9ûô w< +Ò-±,ØMMOð 3?Ð-ú÷/ ñ úsf ¯AE0Á3D ÂE0Â DÂ E0Â!'DÃE Ã 8E0Ä
|
E0Ä EÄ EÄ<E ÅEÅE Å $E-Å-E0Å0E: )ra )Nr¤ NN)Úpythonr r )NN)zItems are not equal:Tr rd )ra T)é ra T)ra Tra é TT)rè ra T)NT)rö N)gH¯¼ò×z>r Tra T)rö )rd FFrö N)rI Úconcurrent.futuresr× r/ rÇ Úimportlib.metadataÚ importlibrV r ÚpathlibrÁ rå rª r$ r} Ú sysconfigrÚ r Ú functoolsr r Úior Útempfiler r Ú unittest.caser r rM rÍ Únumpy.linalg._umath_linalgr
|
r r rË r r r r r r r r Ú__all__r r/ ÚKnownFailureTestr$ ÚPathrz Úparentr@ ÚmetadataÚ distributionÚnp_distr? Ú version_infoÚoriginÚdir_infoÚeditabler> ÚjsonrQ ÚloadsÚ read_textr° Ú locate_fileÚPackageNotFoundErrorr| r4 Úimplementationr^ r2 r* r: r4 r3 rC ÚsystemÚ
|
__config__ÚCONFIGr] ÚKeyErrorÚlinalgÚ _umath_linalgÚ_ilp64r9 r; Úget_config_varÚ_vr r= rÏ ÚitemsizerB r& r r r r r r! r r r6 r r r r# r r" r< ÚunittestÚTestCaser r r r( r r% rÑ r, r' r) rÞ rô rï Úcontextmanagerr r* r r+ r! r- r1 r0 r r. r5 r r7 r8 r r r r rË rÒ rÔ Ú_glibc_older_thanrA rJ rK rL ú<module>r sO ðñó Û Û Û Û Û Û Û Û Û Û Û
|
Û Û Û ß $Ý ß %Ý "Ý #ã Û !ß (Ñ (ß W× WÓ Wò
|
ô$ Iô ð
|
)Ð Ø
|
à W\\"++Ó &× -Ñ -
|
ð Ø× Ñ ×-Ñ-¨gÓ6Gð Lð Ø × Ñ wÒ &Ø!..×1Ñ1×:Ñ:Kó Û Ø TZZØ×!Ñ!Ð"3Ó4Ò<¸Ù FôFð !//×2Ñ2Kñ 7×.Ñ.¨wÓ7¸:ÒEØ à
|
(×
|
Ñ
|
Ó
|
Ð 4Ð
|
4Ø
|
×
|
Ñ
|
×
|
!Ñ
|
! VÑ
|
+Ù CÐ.Ó / ÙsM¨4Ó0¸Ð<ÒNÀYÀ ØÐ Ø8??ÓÒ Ð$4 H×$4Ñ$4Ó$6¸'Ò$Að Ø}}×#Ñ#Ð$8Ñ9¸&ÑAØ <<Ò 'Ø %Ð ð ||×)Ñ)×0Ñ0 à
|
ð
|
Y× Ñ oÓ.Ò4°"Ø R<ØGáÐ+9×+Ñ+Ð,=Ó>Ó? Ø 288BGGÓ × %Ñ %¨Ñ *ó#ð( 77d?à;?Ø?Có$ô8Eð \\"1ÐÒ ô ò"ð <<ÐwÒ ô<ð. ó 8ð +AØGHóð:OÀeô Oòd&-óRz/ðz ACØ $ó`"ðF MOØ@DðE à#(Ð0EôE ðP~(Ø #ô~(ðB CEØ&*óp ðfp+Àô p+òfòD"óN,Kð^ !ó ó, ô X× Ñ ô ñ
|
E]ò,ò: Só +8ó\+ò\ð4 CGØ(,ðj(Ø8=ôj(óZ<"ó~1óh; ò| ò 9ð ×ÒòAó ðAò8%ðv ×ÒòAó ðAò %ðD &¨H¸ró B;ôJ iô ð
|
×Òñ ó ð ð ×Òñó ðô*?Jx× 6Ò 6ô ?J÷DSñ Sðl ×Òò0
|
ó ð0
|
òf òBò$ò, 2ò>9ò"ò0ò(ñ Ó ÙDÐ ð 27Ø67Ø "ô øðwR ò Ø ð ûð! ×Ñ×.Ñ.ò 'Ø!&Ð&L;ð'ûðL ò Ú ð ús7 ÃP> à A6P0 Ç &Q" Ð0P;Ð:P;Ð> Q Ñ Q Ñ"Q+Ñ*Q+
|
