Rename matrx to matrixlib.

I forgot to commit the name change suggested by Stefan.  You need to
clean build/install directory when updating to this version.

1 files changed, 375 insertions, 0 deletions

diff --git a/numpy/matrixlib/tests/test_defmatrix.py b/numpy/matrixlib/tests/test_defmatrix.py
new file mode 100644
index 000000000..cb6bd801d
--- /dev/null
+++ b/numpy/matrixlib/tests/test_defmatrix.py
@@ -0,0 +1,375 @@
+from numpy.testing import *
+from numpy.core import *
+from numpy import matrix, asmatrix, bmat
+from numpy.matrixlib.defmatrix import matrix_power
+from numpy.matrixlib import mat
+import numpy as np
+
+class TestCtor(TestCase):
+    def test_basic(self):
+        A = array([[1,2],[3,4]])
+        mA = matrix(A)
+        assert all(mA.A == A)
+
+        B = bmat("A,A;A,A")
+        C = bmat([[A,A], [A,A]])
+        D = array([[1,2,1,2],
+                   [3,4,3,4],
+                   [1,2,1,2],
+                   [3,4,3,4]])
+        assert all(B.A == D)
+        assert all(C.A == D)
+
+        E = array([[5,6],[7,8]])
+        AEresult = matrix([[1,2,5,6],[3,4,7,8]])
+        assert all(bmat([A,E]) == AEresult)
+
+        vec = arange(5)
+        mvec = matrix(vec)
+        assert mvec.shape == (1,5)
+
+    def test_bmat_nondefault_str(self):
+        A = array([[1,2],[3,4]])
+        B = array([[5,6],[7,8]])
+        Aresult = array([[1,2,1,2],
+                         [3,4,3,4],
+                         [1,2,1,2],
+                         [3,4,3,4]])
+        Bresult = array([[5,6,5,6],
+                         [7,8,7,8],
+                         [5,6,5,6],
+                         [7,8,7,8]])
+        mixresult = array([[1,2,5,6],
+                           [3,4,7,8],
+                           [5,6,1,2],
+                           [7,8,3,4]])
+        assert all(bmat("A,A;A,A") == Aresult)
+        assert all(bmat("A,A;A,A",ldict={'A':B}) == Aresult)
+        assert_raises(TypeError, bmat, "A,A;A,A",gdict={'A':B})
+        assert all(bmat("A,A;A,A",ldict={'A':A},gdict={'A':B}) == Aresult)
+        b2 = bmat("A,B;C,D",ldict={'A':A,'B':B},gdict={'C':B,'D':A})
+        assert all(b2 == mixresult)
+
+
+class TestProperties(TestCase):
+    def test_sum(self):
+        """Test whether matrix.sum(axis=1) preserves orientation.
+        Fails in NumPy <= 0.9.6.2127.
+        """
+        M = matrix([[1,2,0,0],
+                   [3,4,0,0],
+                   [1,2,1,2],
+                   [3,4,3,4]])
+        sum0 = matrix([8,12,4,6])
+        sum1 = matrix([3,7,6,14]).T
+        sumall = 30
+        assert_array_equal(sum0, M.sum(axis=0))
+        assert_array_equal(sum1, M.sum(axis=1))
+        assert sumall == M.sum()
+
+
+    def test_prod(self):
+        x = matrix([[1,2,3],[4,5,6]])
+        assert x.prod() == 720
+        assert all(x.prod(0) == matrix([[4,10,18]]))
+        assert all(x.prod(1) == matrix([[6],[120]]))
+
+        y = matrix([0,1,3])
+        assert y.prod() == 0
+
+    def test_max(self):
+        x = matrix([[1,2,3],[4,5,6]])
+        assert x.max() == 6
+        assert all(x.max(0) == matrix([[4,5,6]]))
+        assert all(x.max(1) == matrix([[3],[6]]))
+
+    def test_min(self):
+        x = matrix([[1,2,3],[4,5,6]])
+        assert x.min() == 1
+        assert all(x.min(0) == matrix([[1,2,3]]))
+        assert all(x.min(1) == matrix([[1],[4]]))
+
+    def test_ptp(self):
+        x = np.arange(4).reshape((2,2))
+        assert x.ptp() == 3
+        assert all(x.ptp(0) == array([2, 2]))
+        assert all(x.ptp(1) == array([1, 1]))
+
+    def test_var(self):
+        x = np.arange(9).reshape((3,3))
+        mx = x.view(np.matrix)
+        assert_equal(x.var(ddof=0), mx.var(ddof=0))
+        assert_equal(x.var(ddof=1), mx.var(ddof=1))
+
+    def test_basic(self):
+        import numpy.linalg as linalg
+
+        A = array([[1., 2.],
+                   [3., 4.]])
+        mA = matrix(A)
+        assert allclose(linalg.inv(A), mA.I)
+        assert all(array(transpose(A) == mA.T))
+        assert all(array(transpose(A) == mA.H))
+        assert all(A == mA.A)
+
+        B = A + 2j*A
+        mB = matrix(B)
+        assert allclose(linalg.inv(B), mB.I)
+        assert all(array(transpose(B) == mB.T))
+        assert all(array(conjugate(transpose(B)) == mB.H))
+
+    def test_pinv(self):
+        x = matrix(arange(6).reshape(2,3))
+        xpinv = matrix([[-0.77777778,  0.27777778],
+                        [-0.11111111,  0.11111111],
+                        [ 0.55555556, -0.05555556]])
+        assert_almost_equal(x.I, xpinv)
+
+    def test_comparisons(self):
+        A = arange(100).reshape(10,10)
+        mA = matrix(A)
+        mB = matrix(A) + 0.1
+        assert all(mB == A+0.1)
+        assert all(mB == matrix(A+0.1))
+        assert not any(mB == matrix(A-0.1))
+        assert all(mA < mB)
+        assert all(mA <= mB)
+        assert all(mA <= mA)
+        assert not any(mA < mA)
+
+        assert not any(mB < mA)
+        assert all(mB >= mA)
+        assert all(mB >= mB)
+        assert not any(mB > mB)
+
+        assert all(mA == mA)
+        assert not any(mA == mB)
+        assert all(mB != mA)
+
+        assert not all(abs(mA) > 0)
+        assert all(abs(mB > 0))
+
+    def test_asmatrix(self):
+        A = arange(100).reshape(10,10)
+        mA = asmatrix(A)
+        A[0,0] = -10
+        assert A[0,0] == mA[0,0]
+
+    def test_noaxis(self):
+        A = matrix([[1,0],[0,1]])
+        assert A.sum() == matrix(2)
+        assert A.mean() == matrix(0.5)
+
+    def test_repr(self):
+        A = matrix([[1,0],[0,1]])
+        assert repr(A) == "matrix([[1, 0],\n        [0, 1]])"
+
+class TestCasting(TestCase):
+    def test_basic(self):
+        A = arange(100).reshape(10,10)
+        mA = matrix(A)
+
+        mB = mA.copy()
+        O = ones((10,10), float64) * 0.1
+        mB = mB + O
+        assert mB.dtype.type == float64
+        assert all(mA != mB)
+        assert all(mB == mA+0.1)
+
+        mC = mA.copy()
+        O = ones((10,10), complex128)
+        mC = mC * O
+        assert mC.dtype.type == complex128
+        assert all(mA != mB)
+
+
+class TestAlgebra(TestCase):
+    def test_basic(self):
+        import numpy.linalg as linalg
+
+        A = array([[1., 2.],
+                   [3., 4.]])
+        mA = matrix(A)
+
+        B = identity(2)
+        for i in xrange(6):
+            assert allclose((mA ** i).A, B)
+            B = dot(B, A)
+
+        Ainv = linalg.inv(A)
+        B = identity(2)
+        for i in xrange(6):
+            assert allclose((mA ** -i).A, B)
+            B = dot(B, Ainv)
+
+        assert allclose((mA * mA).A, dot(A, A))
+        assert allclose((mA + mA).A, (A + A))
+        assert allclose((3*mA).A, (3*A))
+
+        mA2 = matrix(A)
+        mA2 *= 3
+        assert allclose(mA2.A, 3*A)
+
+    def test_pow(self):
+        """Test raising a matrix to an integer power works as expected."""
+        m = matrix("1. 2.; 3. 4.")
+        m2 = m.copy()
+        m2 **= 2
+        mi = m.copy()
+        mi **= -1
+        m4 = m2.copy()
+        m4 **= 2
+        assert_array_almost_equal(m2, m**2)
+        assert_array_almost_equal(m4, np.dot(m2, m2))
+        assert_array_almost_equal(np.dot(mi, m), np.eye(2))
+
+    def test_notimplemented(self):
+        '''Check that 'not implemented' operations produce a failure.'''
+        A = matrix([[1., 2.],
+                    [3., 4.]])
+
+        # __rpow__
+        try:
+            1.0**A
+        except TypeError:
+            pass
+        else:
+            self.fail("matrix.__rpow__ doesn't raise a TypeError")
+
+        # __mul__ with something not a list, ndarray, tuple, or scalar
+        try:
+            A*object()
+        except TypeError:
+            pass
+        else:
+            self.fail("matrix.__mul__ with non-numeric object doesn't raise"
+                      "a TypeError")
+
+class TestMatrixReturn(TestCase):
+    def test_instance_methods(self):
+        a = matrix([1.0], dtype='f8')
+        methodargs = {
+            'astype' : ('intc',),
+            'clip' : (0.0, 1.0),
+            'compress' : ([1],),
+            'repeat' : (1,),
+            'reshape' : (1,),
+            'swapaxes' : (0,0)
+            }
+        excluded_methods = [
+            'argmin', 'choose', 'dump', 'dumps', 'fill', 'getfield',
+            'getA', 'getA1', 'item', 'nonzero', 'put', 'putmask', 'resize',
+            'searchsorted', 'setflags', 'setfield', 'sort', 'take',
+            'tofile', 'tolist', 'tostring', 'all', 'any', 'sum',
+            'argmax', 'argmin', 'min', 'max', 'mean', 'var', 'ptp',
+            'prod', 'std', 'ctypes', 'itemset'
+            ]
+        for attrib in dir(a):
+            if attrib.startswith('_') or attrib in excluded_methods:
+                continue
+            f = eval('a.%s' % attrib)
+            if callable(f):
+                # reset contents of a
+                a.astype('f8')
+                a.fill(1.0)
+                if attrib in methodargs:
+                    args = methodargs[attrib]
+                else:
+                    args = ()
+                b = f(*args)
+                assert type(b) is matrix, "%s" % attrib
+        assert type(a.real) is matrix
+        assert type(a.imag) is matrix
+        c,d = matrix([0.0]).nonzero()
+        assert type(c) is matrix
+        assert type(d) is matrix
+
+
+class TestIndexing(TestCase):
+    def test_basic(self):
+        x = asmatrix(zeros((3,2),float))
+        y = zeros((3,1),float)
+        y[:,0] = [0.8,0.2,0.3]
+        x[:,1] = y>0.5
+        assert_equal(x, [[0,1],[0,0],[0,0]])
+
+
+class TestNewScalarIndexing(TestCase):
+    def setUp(self):
+        self.a = matrix([[1, 2],[3,4]])
+
+    def test_dimesions(self):
+        a = self.a
+        x = a[0]
+        assert_equal(x.ndim, 2)
+
+    def test_array_from_matrix_list(self):
+        a = self.a
+        x = array([a, a])
+        assert_equal(x.shape, [2,2,2])
+
+    def test_array_to_list(self):
+        a = self.a
+        assert_equal(a.tolist(),[[1, 2], [3, 4]])
+
+    def test_fancy_indexing(self):
+        a = self.a
+        x = a[1, [0,1,0]]
+        assert isinstance(x, matrix)
+        assert_equal(x, matrix([[3,  4,  3]]))
+        x = a[[1,0]]
+        assert isinstance(x, matrix)
+        assert_equal(x, matrix([[3,  4], [1, 2]]))
+        x = a[[[1],[0]],[[1,0],[0,1]]]
+        assert isinstance(x, matrix)
+        assert_equal(x, matrix([[4,  3], [1,  2]]))
+
+    def test_matrix_element(self):
+        x = matrix([[1,2,3],[4,5,6]])
+        assert_equal(x[0][0],matrix([[1,2,3]]))
+        assert_equal(x[0][0].shape,(1,3))
+        assert_equal(x[0].shape,(1,3))
+        assert_equal(x[:,0].shape,(2,1))
+
+        x = matrix(0)
+        assert_equal(x[0,0],0)
+        assert_equal(x[0],0)
+        assert_equal(x[:,0].shape,x.shape)
+
+    def test_scalar_indexing(self):
+        x = asmatrix(zeros((3,2),float))
+        assert_equal(x[0,0],x[0][0])
+
+    def test_row_column_indexing(self):
+        x = asmatrix(np.eye(2))
+        assert_array_equal(x[0,:],[[1,0]])
+        assert_array_equal(x[1,:],[[0,1]])
+        assert_array_equal(x[:,0],[[1],[0]])
+        assert_array_equal(x[:,1],[[0],[1]])
+
+    def test_boolean_indexing(self):
+        A = arange(6)
+        A.shape = (3,2)
+        x = asmatrix(A)
+        assert_array_equal(x[:,array([True,False])],x[:,0])
+        assert_array_equal(x[array([True,False,False]),:],x[0,:])
+
+    def test_list_indexing(self):
+        A = arange(6)
+        A.shape = (3,2)
+        x = asmatrix(A)
+        assert_array_equal(x[:,[1,0]],x[:,::-1])
+        assert_array_equal(x[[2,1,0],:],x[::-1,:])
+
+class TestPower(TestCase):
+    def test_returntype(self):
+        a = array([[0,1],[0,0]])
+        assert type(matrix_power(a, 2)) is ndarray
+        a = mat(a)
+        assert type(matrix_power(a, 2)) is matrix
+
+    def test_list(self):
+        assert_array_equal(matrix_power([[0, 1], [0, 0]], 2), [[0, 0], [0, 0]])
+
+if __name__ == "__main__":
+    run_module_suite()