lsst.utils.tests Namespace Reference

Classes
class	MemoryTestCase
class	temporaryFile
class	TestCase

Functions
def	init
def	run
def	findFileFromRoot
def	inTestCase
def	assertRaisesLsstCpp
def	debugger
def	plotImageDiff
def	assertClose
def	assertNotClose

Variables
	dafBase = None
int	memId0 = 0
int	nleakPrintMax = 20

Function Documentation

def lsst.utils.tests.assertClose	(		testCase,
			lhs,
			rhs,
			rtol = sys.float_info.epsilon,
			atol = sys.float_info.epsilon,
			relTo = None,
			printFailures = True,
			plotOnFailure = False,
			plotFileName = None,
			invert = False
	)

Highly-configurable floating point comparisons for scalars and arrays.

The test assertion will fail if all elements lhs and rhs are not equal to within the tolerances
specified by rtol and atol.  More precisely, the comparison is:

abs(lhs - rhs) <= relTo*rtol OR abs(lhs - rhs) <= atol

If rtol or atol is None, that term in the comparison is not performed at all.

When not specified, relTo is the elementwise maximum of the absolute values of lhs and rhs.  If
set manually, it should usually be set to either lhs or rhs, or a scalar value typical of what
is expected.

@param[in]  testCase       unittest.TestCase instance the test is part of
@param[in]  lhs            LHS value(s) to compare; may be a scalar or a numpy array of any dimension
@param[in]  rhs            RHS value(s) to compare; may be a scalar or a numpy array of any dimension
@param[in]  rtol           Relative tolerance for comparison; defaults to double-precision epsilon.
@param[in]  atol           Absolute tolerance for comparison; defaults to double-precision epsilon.
@param[in]  relTo          Value to which comparison with rtol is relative.
@param[in]  printFailures  Upon failure, print all inequal elements as part of the message.
@param[in]  plotOnFailure  Upon failure, plot the originals and their residual with matplotlib.
                           Only 2-d arrays are supported.
@param[in]  plotFileName   Filename to save the plot to.  If None, the plot will be displayed in a
                           a window.
@param[in]  invert         If True, invert the comparison and fail only if any elements *are* equal.
                           Used to implement assertNotClose, which should generally be used instead
                           for clarity.

Definition at line 245 of file tests.py.

                printFailures=True, plotOnFailure=False, plotFileName=None, invert=False):
    """Highly-configurable floating point comparisons for scalars and arrays.

    The test assertion will fail if all elements lhs and rhs are not equal to within the tolerances
    specified by rtol and atol.  More precisely, the comparison is:

    abs(lhs - rhs) <= relTo*rtol OR abs(lhs - rhs) <= atol

    If rtol or atol is None, that term in the comparison is not performed at all.

    When not specified, relTo is the elementwise maximum of the absolute values of lhs and rhs.  If
    set manually, it should usually be set to either lhs or rhs, or a scalar value typical of what
    is expected.

    @param[in]  testCase       unittest.TestCase instance the test is part of
    @param[in]  lhs            LHS value(s) to compare; may be a scalar or a numpy array of any dimension
    @param[in]  rhs            RHS value(s) to compare; may be a scalar or a numpy array of any dimension
    @param[in]  rtol           Relative tolerance for comparison; defaults to double-precision epsilon.
    @param[in]  atol           Absolute tolerance for comparison; defaults to double-precision epsilon.
    @param[in]  relTo          Value to which comparison with rtol is relative.
    @param[in]  printFailures  Upon failure, print all inequal elements as part of the message.
    @param[in]  plotOnFailure  Upon failure, plot the originals and their residual with matplotlib.
                               Only 2-d arrays are supported.
    @param[in]  plotFileName   Filename to save the plot to.  If None, the plot will be displayed in a
                               a window.
    @param[in]  invert         If True, invert the comparison and fail only if any elements *are* equal.
                               Used to implement assertNotClose, which should generally be used instead
                               for clarity.
    """
    if not numpy.isfinite(lhs).all():
        testCase.fail("Non-finite values in lhs")
    if not numpy.isfinite(rhs).all():
        testCase.fail("Non-finite values in rhs")
    diff = lhs - rhs
    absDiff = numpy.abs(lhs - rhs)
    if rtol is not None:
        if relTo is None:
            relTo = numpy.maximum(numpy.abs(lhs), numpy.abs(rhs))
        else:
            relTo = numpy.abs(relTo)
        bad = absDiff > rtol*relTo
        if atol is not None:
            bad = numpy.logical_and(bad, absDiff > atol)
    else:
        if atol is None:
            raise ValueError("rtol and atol cannot both be None")
        bad = absDiff > atol
    failed = numpy.any(bad)
    if invert:
        failed = not failed
        bad = numpy.logical_not(bad)
        cmpStr = "=="
        failStr = "are the same"
    else:
        cmpStr = "!="
        failStr = "differ"
    msg = []
    if failed:
        if numpy.isscalar(bad):
            msg = ["%s %s %s; diff=%s/%s=%s with rtol=%s, atol=%s"
                   % (lhs, cmpStr, rhs, absDiff, relTo, absDiff/relTo, rtol, atol)]
        else:
            msg = ["%d/%d elements %s with rtol=%s, atol=%s"
                   % (bad.sum(), bad.size, failStr, rtol, atol)]
            if plotOnFailure:
                if len(lhs.shape) != 2 or len(rhs.shape) != 2:
                    raise ValueError("plotOnFailure is only valid for 2-d arrays")
                try:
                    plotImageDiff(lhs, rhs, bad, diff=diff, plotFileName=plotFileName)
                except ImportError:
                    msg.append("Failure plot requested but matplotlib could not be imported.")
            if printFailures:
                # Make sure everything is an array if any of them are, so we can treat
                # them the same (diff and absDiff are arrays if either rhs or lhs is),
                # and we don't get here if neither is.
                if numpy.isscalar(relTo):
                    relTo = numpy.ones(bad.shape, dtype=float) * relTo
                if numpy.isscalar(lhs):
                    lhs = numpy.ones(bad.shape, dtype=float) * lhs
                if numpy.isscalar(rhs):
                    rhs = numpy.ones(bad.shape, dtype=float) * rhs
                for a, b, diff, rel in zip(lhs[bad], rhs[bad], absDiff[bad], relTo[bad]):
                    msg.append("%s %s %s (diff=%s/%s=%s)" % (a, cmpStr, b, diff, rel, diff/rel))
    testCase.assertFalse(failed, msg="\n".join(msg))