numpy.testing.utils
index
/usr/lib/python2.6/dist-packages/numpy/testing/utils.py

Utility function to facilitate testing.

 
Modules
       
operator
os
re
sys

 
Functions
       
assert_(val, msg='')
Assert that works in release mode.
assert_almost_equal(actual, desired, decimal=7, err_msg='', verbose=True)
Raise an assertion if two items are not equal up to desired precision.
 
The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal)
 
Given two objects (numbers or ndarrays), check that all elements of these
objects are almost equal. An exception is raised at conflicting values.
For ndarrays this delegates to assert_array_almost_equal
 
Parameters
----------
actual : number or ndarray
  The object to check.
desired : number or ndarray
  The expected object.
decimal : integer (decimal=7)
  desired precision
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 are not equal up to specified precision.
 
See Also
--------
assert_array_almost_equal: compares array_like objects
assert_equal: tests objects for equality
 
 
Examples
--------
>>> npt.assert_almost_equal(2.3333333333333, 2.33333334)
>>> npt.assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
...
<type 'exceptions.AssertionError'>:
Items are not equal:
 ACTUAL: 2.3333333333333002
 DESIRED: 2.3333333399999998
 
>>> npt.assert_almost_equal(np.array([1.0,2.3333333333333]),
                    np.array([1.0,2.33333334]), decimal=9)
...
<type 'exceptions.AssertionError'>:
Arrays are not almost equal
<BLANKLINE>
(mismatch 50.0%)
 x: array([ 1.        ,  2.33333333])
 y: array([ 1.        ,  2.33333334])
assert_approx_equal(actual, desired, significant=7, err_msg='', verbose=True)
Raise an assertion if two items are not equal up to significant digits.
 
Given two numbers, check that they are approximately equal.
Approximately equal is defined as the number of significant digits
that agree.
 
Parameters
----------
actual : number
  The object to check.
desired : number
  The expected object.
significant : integer (significant=7)
  desired precision
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 are not equal up to specified precision.
 
See Also
--------
assert_almost_equal: compares objects by decimals
assert_array_almost_equal: compares array_like objects by decimals
assert_equal: tests objects for equality
 
 
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)
...
<type 'exceptions.AssertionError'>:
Items are not equal to 8 significant digits:
 ACTUAL: 1.234567e-021
 DESIRED: 1.2345672000000001e-021
 
the evaluated condition that raises the exception is
 
>>> abs(0.12345670e-20/1e-21 - 0.12345672e-20/1e-21) >= 10**-(8-1)
True
assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True)
Raise an assertion if two objects are not equal up to desired precision.
 
The test verifies identical shapes and verifies values with
abs(desired-actual) < 0.5 * 10**(-decimal)
 
Given two array_like objects, check that the shape is equal and all
elements of these objects are almost equal. 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 : integer (decimal=6)
  desired precision
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 are not equal up to specified precision.
 
See Also
--------
assert_almost_equal: simple version for comparing numbers
assert_array_equal: tests objects for equality
 
 
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)
...
<type 'exceptions.AssertionError'>:
AssertionError:
Arrays are not almost equal
<BLANKLINE>
(mismatch 50.0%)
 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)
<type 'exceptions.ValueError'>:
ValueError:
Arrays are not almost equal
 x: array([ 1.     ,  2.33333,      NaN])
 y: array([ 1.     ,  2.33333,  5.     ])
assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='')
assert_array_equal(x, y, err_msg='', verbose=True)
Raise an assertion 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. 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 : 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_almost_equal: test objects for equality up to precision
assert_equal: tests objects for equality
 
 
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 inprecision with floats
 
>>> np.testing.assert_array_equal([1.0,np.pi,np.nan],
                    [1, np.sqrt(np.pi)**2, np.nan])
...
<type 'exceptions.ValueError'>:
AssertionError:
Arrays are not equal
<BLANKLINE>
(mismatch 50.0%)
 x: array([ 1.        ,  3.14159265,         NaN])
 y: array([ 1.        ,  3.14159265,         NaN])
 
use assert_array_almost_equal for these cases instead
 
>>> np.testing.assert_array_almost_equal([1.0,np.pi,np.nan],
                    [1, np.sqrt(np.pi)**2, np.nan], decimal=15)
assert_array_less(x, y, err_msg='', verbose=True)
Raise an assertion 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])
...
<type 'exceptions.ValueError'>:
Arrays are not less-ordered
(mismatch 50.0%)
 x: array([  1.,   1.,  NaN])
 y: array([  1.,   2.,  NaN])
 
>>> np.testing.assert_array_less([1.0, 4.0], 3)
...
<type 'exceptions.ValueError'>:
Arrays are not less-ordered
(mismatch 50.0%)
 x: array([ 1.,  4.])
 y: array(3)
 
>>> np.testing.assert_array_less([1.0, 2.0, 3.0], [4])
...
<type 'exceptions.ValueError'>:
Arrays are not less-ordered
(shapes (3,), (1,) mismatch)
 x: array([ 1.,  2.,  3.])
 y: array([4])
assert_equal(actual, desired, err_msg='', verbose=True)
Raise an assertion if two objects are not equal.
 
Given two objects (lists, tuples, dictionaries or numpy arrays), check
that all elements of these objects are equal. An exception is raised at
the first conflicting values.
 
Parameters
----------
actual : list, tuple, dict or ndarray
  The object to check.
desired : list, tuple, dict or ndarray
  The expected object.
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 are not equal.
 
Examples
--------
>>> np.testing.assert_equal([4,5], [4,6])
...
<type 'exceptions.AssertionError'>:
Items are not equal:
item=1
 ACTUAL: 5
 DESIRED: 6
assert_raises(*args, **kwargs)
assert_raises(excecption_class, callable, *args, **kwargs)
 
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.
assert_string_equal(actual, desired)
build_err_msg(arrays, err_msg, header='Items are not equal:', verbose=True, names=('ACTUAL', 'DESIRED'))
decorate_methods(cls, decorator, testmatch=None)
Apply decorator to all methods in class matching testmatch
 
Parameters
----------
cls : class
    Class to decorate methods for
decorator : function
    Decorator to apply to methods
testmatch : compiled regexp or string to compile to regexp
    Decorators are applied if testmatch.search(methodname)
    is not None.  Default value is
    re.compile(r'(?:^|[\b_\.%s-])[Tt]est' % os.sep)
    (the default for nose)
jiffies(_proc_pid_stat='/proc/17578/stat', _load_time=[])
Return number of jiffies (1/100ths of a second) that this
process has been scheduled in user mode. See man 5 proc.
measure(code_str, times=1, label=None)
Return elapsed time for executing code_str in the
namespace of the caller for given times.
memusage(_proc_pid_stat='/proc/17578/stat')
Return virtual memory size in bytes of the running python.
print_assert_equal(test_string, actual, desired)
raises(*args, **kwargs)
rand(*args)
Returns an array of random numbers with the given shape.
 
This only uses the standard library, so it is useful for testing purposes.
rundocs(filename=None)
Run doc string tests found in filename.
runstring(astr, dict)

 
Data
        __all__ = ['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', 'rand', 'rundocs', 'runstring', 'verbose', 'measure', 'assert_']
__file__ = '/usr/lib/python2.6/dist-packages/numpy/testing/utils.pyc'
__name__ = 'numpy.testing.utils'
__package__ = 'numpy.testing'
verbose = 0