Two floating point numbers should not be compared with the == comparison, because the result of a computation is often slightly off due to rounding errors. There are numerous tools to test equality of floats for testing purposes. First, allclose checks that two arrays are almost equal. It can be used in a test function, as shown:

self.assertTrue(allclose(computed, expected))

Here, self refers to a unittest.Testcase instance. There are also testing tools in the numpy package testing. These are imported by using:

import numpy.testing

Testing that two scalars or two arrays are equal is done using numpy.testing.assert_array_allmost_equal or numpy.testing.assert_allclose. These methods differ in the way they describe the required accuracy, as shown in the preceding table.

QR factorization decomposes a given matrix into a product of an orthogonal matrix Q and an upper triangular matrix R as given in the following example:

import scipy.linalg as sl
A=rand(10,10)
[Q,R]=sl.qr(A)

Is the method applied correctly? We can check this by verifying that Q is indeed an orthogonal matrix:

import numpy.testing as npt 
npt.assert_allclose(
               dot(Q.T,self.Q),identity(Q.shape[0]),atol=1.e-12)

Furthermore, we might perform a sanity test by checking if A = QR:

import numpy.testing as npt
npt.assert_allclose(dot(Q,R),A))

All this can be collected into a unittest test case as follows:

import unittest
import numpy.testing as npt
from scipy.linalg import qr
from scipy import *

class TestQR(unittest.TestCase):
    def setUp(self):
        self.A=rand(10,10)
        [self.Q,self.R]=qr(self.A)
    def test_orthogonal(self):
        npt.assert_allclose(
            dot(self.Q.T,self.Q),identity(self.Q.shape[0]),
                                                        atol=1.e-12)
    def test_sanity(self):
            npt.assert_allclose(dot(self.Q,self.R),self.A)

if __name__=='__main__':
    unittest.main()

Note in assert_allclose the parameter atol defaults to zero, which often causes problems, when working with matrices having small elements.