[Numpy-svn] r5103 - in trunk/numpy/linalg: . tests

numpy-svn@scip... numpy-svn@scip...
Sun Apr 27 13:19:15 CDT 2008


Author: charris
Date: 2008-04-27 13:19:12 -0500 (Sun, 27 Apr 2008)
New Revision: 5103

Modified:
   trunk/numpy/linalg/linalg.py
   trunk/numpy/linalg/tests/test_linalg.py
Log:
Add tests for matrix return types.
Fix cond computations for matrices.
lstsq is currently broken for matrices, will fix shortly.


Modified: trunk/numpy/linalg/linalg.py
===================================================================
--- trunk/numpy/linalg/linalg.py	2008-04-27 15:27:30 UTC (rev 5102)
+++ trunk/numpy/linalg/linalg.py	2008-04-27 18:19:12 UTC (rev 5103)
@@ -27,7 +27,7 @@
         isfinite, size
 from numpy.lib import triu
 from numpy.linalg import lapack_lite
-from numpy.core.defmatrix import matrix_power
+from numpy.core.defmatrix import matrix_power, matrix
 
 fortran_int = intc
 
@@ -983,7 +983,7 @@
     else:
         return wrap(s)
 
-def cond(x,p=None):
+def cond(x, p=None):
     """Compute the condition number of a matrix.
 
     The condition number of x is the norm of x times the norm
@@ -1014,6 +1014,7 @@
     c : float
         The condition number of the matrix. May be infinite.
     """
+    x = asarray(x) # in case we have a matrix
     if p is None:
         s = svd(x,compute_uv=False)
         return s[0]/s[-1]
@@ -1146,7 +1147,7 @@
 
     """
     import math
-    a = asarray(a)
+    a = _makearray(a)
     b, wrap = _makearray(b)
     one_eq = len(b.shape) == 1
     if one_eq:

Modified: trunk/numpy/linalg/tests/test_linalg.py
===================================================================
--- trunk/numpy/linalg/tests/test_linalg.py	2008-04-27 15:27:30 UTC (rev 5102)
+++ trunk/numpy/linalg/tests/test_linalg.py	2008-04-27 18:19:12 UTC (rev 5103)
@@ -3,13 +3,19 @@
 
 from numpy.testing import *
 set_package_path()
-from numpy import array, single, double, csingle, cdouble, dot, identity, \
-        multiply, atleast_2d, inf, asarray
+from numpy import array, single, double, csingle, cdouble, dot, identity
+from numpy import multiply, atleast_2d, inf, asarray, matrix
 from numpy import linalg
 from linalg import matrix_power
 restore_path()
 
+def ifthen(a, b):
+    return not a or b
+
 old_assert_almost_equal = assert_almost_equal
+def imply(a, b):
+    return not a or b
+
 def assert_almost_equal(a, b, **kw):
     if asarray(a).dtype.type in (single, csingle):
         decimal = 6
@@ -52,41 +58,63 @@
         b = [2, 1]
         self.do(a,b)
 
+    def check_matrix_b_only(self):
+        """Check that matrix type is preserved."""
+        a = array([[1.,2.], [3.,4.]])
+        b = matrix([2., 1.]).T
+        self.do(a, b)
 
+    def check_matrix_a_and_b(self):
+        """Check that matrix type is preserved."""
+        a = matrix([[1.,2.], [3.,4.]])
+        b = matrix([2., 1.]).T
+        self.do(a, b)
+
+
 class TestSolve(LinalgTestCase):
     def do(self, a, b):
         x = linalg.solve(a, b)
         assert_almost_equal(b, dot(a, x))
+        assert imply(isinstance(b, matrix), isinstance(x, matrix))
 
 class TestInv(LinalgTestCase):
     def do(self, a, b):
         a_inv = linalg.inv(a)
         assert_almost_equal(dot(a, a_inv), identity(asarray(a).shape[0]))
+        assert imply(isinstance(a, matrix), isinstance(a_inv, matrix))
 
 class TestEigvals(LinalgTestCase):
     def do(self, a, b):
         ev = linalg.eigvals(a)
         evalues, evectors = linalg.eig(a)
         assert_almost_equal(ev, evalues)
+        assert imply(isinstance(a, matrix), isinstance(ev, matrix))
 
 class TestEig(LinalgTestCase):
     def do(self, a, b):
         evalues, evectors = linalg.eig(a)
-        assert_almost_equal(dot(a, evectors), evectors*evalues)
+        assert_almost_equal(dot(a, evectors), multiply(evectors, evalues))
+        assert imply(isinstance(a, matrix), isinstance(evalues, matrix))
+        assert imply(isinstance(a, matrix), isinstance(evectors, matrix))
 
 class TestSVD(LinalgTestCase):
     def do(self, a, b):
         u, s, vt = linalg.svd(a, 0)
-        assert_almost_equal(a, dot(u*s, vt))
+        assert_almost_equal(a, dot(multiply(u, s), vt))
+        assert imply(isinstance(a, matrix), isinstance(u, matrix))
+        assert imply(isinstance(a, matrix), isinstance(s, matrix))
+        assert imply(isinstance(a, matrix), isinstance(vt, matrix))
 
 class TestCondSVD(LinalgTestCase):
     def do(self, a, b):
-        s = linalg.svd(a, compute_uv=False)
+        c = asarray(a) # a might be a matrix
+        s = linalg.svd(c, compute_uv=False)
         old_assert_almost_equal(s[0]/s[-1], linalg.cond(a), decimal=5)
 
 class TestCond2(LinalgTestCase):
     def do(self, a, b):
-        s = linalg.svd(a, compute_uv=False)
+        c = asarray(a) # a might be a matrix
+        s = linalg.svd(c, compute_uv=False)
         old_assert_almost_equal(s[0]/s[-1], linalg.cond(a,2), decimal=5)
 
 class TestCondInf(NumpyTestCase):
@@ -98,6 +126,7 @@
     def do(self, a, b):
         a_ginv = linalg.pinv(a)
         assert_almost_equal(dot(a, a_ginv), identity(asarray(a).shape[0]))
+        assert imply(isinstance(a, matrix), isinstance(a_ginv, matrix))
 
 class TestDet(LinalgTestCase):
     def do(self, a, b):
@@ -116,6 +145,9 @@
         assert_almost_equal(b, dot(a, x))
         assert_equal(rank, asarray(a).shape[0])
         assert_almost_equal(sv, s)
+        assert imply(isinstance(b, matrix), isinstance(x, matrix))
+        assert imply(isinstance(b, matrix), isinstance(residuals, matrix))
+        assert imply(isinstance(b, matrix), isinstance(sv, matrix))
 
 class TestMatrixPower(ParametricTestCase):
     R90 = array([[0,1],[-1,0]])



More information about the Numpy-svn mailing list