[Numpy-svn] r3672 - trunk/numpy/doc/swig

numpy-svn@scip... numpy-svn@scip...
Thu Apr 5 17:20:22 CDT 2007


Author: wfspotz@sandia.gov
Date: 2007-04-05 17:20:15 -0500 (Thu, 05 Apr 2007)
New Revision: 3672

Added:
   trunk/numpy/doc/swig/testMatrix.py
   trunk/numpy/doc/swig/testTensor.py
   trunk/numpy/doc/swig/testVector.py
Removed:
   trunk/numpy/doc/swig/test1D.py
   trunk/numpy/doc/swig/test2D.py
   trunk/numpy/doc/swig/test3D.py
Modified:
   trunk/numpy/doc/swig/Makefile
   trunk/numpy/doc/swig/README
Log:
Removed test1D.py, test2D.py and test3D.py in favor of testVector.py, testMatrix.py and testTensor.py because these new tests use inheritance to duplicate same tests for different data types

Modified: trunk/numpy/doc/swig/Makefile
===================================================================
--- trunk/numpy/doc/swig/Makefile	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/Makefile	2007-04-05 22:20:15 UTC (rev 3672)
@@ -27,9 +27,9 @@
 	./setup.py build
 
 test: all
-	test1D.py
-	test2D.py
-	test3D.py
+	testVector.py
+	testMatrix.py
+	testTensor.py
 
 doc: html pdf
 

Modified: trunk/numpy/doc/swig/README
===================================================================
--- trunk/numpy/doc/swig/README	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/README	2007-04-05 22:20:15 UTC (rev 3672)
@@ -14,17 +14,17 @@
     Vector.h
     Vector.cxx
     Vector.i
-    test1D.py
+    testVector.py
 
     Matrix.h
     Matrix.cxx
     Matrix.i
-    test2D.py
+    testMatrix.py
 
     Tensor.h
     Tensor.cxx
     Tensor.i
-    test3D.py
+    testTensor.py
 
 The header files contain prototypes for functions that illustrate the
 wrapping issues we wish to address.  Right now, this consists of
@@ -83,9 +83,9 @@
 
 The source files Vector.cxx, Matrix.cxx and Tensor.cxx contain the
 actual implementations of the functions described in Vector.h,
-Matrix.h and Tensor.h.  The python scripts test1D.py, test2D.py and
-test3D.py test the resulting python wrappers using the unittest
-module.
+Matrix.h and Tensor.h.  The python scripts testVector.py,
+testMatrix.py and testTensor.py test the resulting python wrappers
+using the unittest module.
 
 The SWIG interface files Vector.i, Matrix.i and Tensor.i are used to
 generate the wrapper code.  The SWIG_FILE_WITH_INIT macro allows

Deleted: trunk/numpy/doc/swig/test1D.py
===================================================================
--- trunk/numpy/doc/swig/test1D.py	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/test1D.py	2007-04-05 22:20:15 UTC (rev 3672)
@@ -1,719 +0,0 @@
-#! /usr/bin/env python
-
-# System imports
-from   distutils.util import get_platform
-import os
-import sys
-import unittest
-
-# Import NumPy
-import numpy as N
-major, minor = [ int(d) for d in N.__version__.split(".")[:2] ]
-if major == 0: BadListError = TypeError
-else:          BadListError = ValueError
-
-# Add the distutils-generated build directory to the python search path and then
-# import the extension module
-libDir = "lib.%s-%s" % (get_platform(), sys.version[:3])
-sys.path.insert(0,os.path.join("build", libDir))
-import Vector
-
-######################################################################
-
-class VectorTestCase(unittest.TestCase):
-
-    ####################################################
-    ### Test functions that take arrays of type BYTE ###
-    def testScharLength(self):
-        "Test scharLength function"
-        self.assertEquals(Vector.scharLength([5, 12, 0]), 13)
-
-    def testScharLengthBad(self):
-        "Test scharLength function for wrong size"
-        self.assertRaises(TypeError, Vector.scharLength, [5, 12])
-
-    def testScharProd(self):
-        "Test scharProd function"
-        self.assertEquals(Vector.scharProd([1,2,3,4]), 24)
-
-    def testScharProdNonContainer(self):
-        "Test scharProd function with None"
-        self.assertRaises(TypeError, Vector.scharProd, None)
-
-    def testScharSum(self):
-        "Test scharSum function"
-        self.assertEquals(Vector.scharSum([-5,6,-7,8]), 2)
-
-    def testScharReverse(self):
-        "Test scharReverse function"
-        vector = N.array([1,2,4],'b')
-        Vector.scharReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testScharOnes(self):
-        "Test scharOnes function"
-        myArray = N.zeros(5,'b')
-        Vector.scharOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testScharZeros(self):
-        "Test scharZeros function"
-        myArray = N.ones(5,'b')
-        Vector.scharZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testScharEOSplit(self):
-        "Test scharEOSplit function"
-        even, odd = Vector.scharEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testScharTwos(self):
-        "Test scharTwos function"
-        twos = Vector.scharTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testScharThrees(self):
-        "Test scharThrees function"
-        threes = Vector.scharThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type UBYTE ###
-    def testUcharLength(self):
-        "Test ucharLength function"
-        self.assertEquals(Vector.ucharLength([5, 12, 0]), 13)
-
-    def testUcharLengthBad(self):
-        "Test ucharLength function for wrong size"
-        self.assertRaises(TypeError, Vector.ucharLength, [5, 12])
-
-    def testUcharProd(self):
-        "Test ucharProd function"
-        self.assertEquals(Vector.ucharProd([1,2,3,4]), 24)
-
-    def testUcharProdNonContainer(self):
-        "Test ucharProd function with None"
-        self.assertRaises(TypeError, Vector.ucharProd, None)
-
-    def testUcharSum(self):
-        "Test ucharSum function"
-        self.assertEquals(Vector.ucharSum([5,6,7,8]), 26)
-
-    def testUcharReverse(self):
-        "Test ucharReverse function"
-        vector = N.array([1,2,4],'B')
-        Vector.ucharReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testUcharOnes(self):
-        "Test ucharOnes function"
-        myArray = N.zeros(5,'B')
-        Vector.ucharOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testUcharZeros(self):
-        "Test ucharZeros function"
-        myArray = N.ones(5,'B')
-        Vector.ucharZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testUcharEOSplit(self):
-        "Test ucharEOSplit function"
-        even, odd = Vector.ucharEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testUcharTwos(self):
-        "Test ucharTwos function"
-        twos = Vector.ucharTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testUcharThrees(self):
-        "Test ucharThrees function"
-        threes = Vector.ucharThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type SHORT ###
-    def testShortLength(self):
-        "Test shortLength function"
-        self.assertEquals(Vector.shortLength([5, 12, 0]), 13)
-
-    def testShortLengthBad(self):
-        "Test shortLength function for wrong size"
-        self.assertRaises(TypeError, Vector.shortLength, [5, 12])
-
-    def testShortProd(self):
-        "Test shortProd function"
-        self.assertEquals(Vector.shortProd([1,2,3,4]), 24)
-
-    def testShortProdNonContainer(self):
-        "Test shortProd function with None"
-        self.assertRaises(TypeError, Vector.shortProd, None)
-
-    def testShortSum(self):
-        "Test shortSum function"
-        self.assertEquals(Vector.shortSum([-5,6,-7,8]), 2)
-
-    def testShortReverse(self):
-        "Test shortReverse function"
-        vector = N.array([1,2,4],'h')
-        Vector.shortReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testShortOnes(self):
-        "Test shortOnes function"
-        myArray = N.zeros(5,'h')
-        Vector.shortOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testShortZeros(self):
-        "Test shortZeros function"
-        myArray = N.ones(5,'h')
-        Vector.shortZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testShortEOSplit(self):
-        "Test shortEOSplit function"
-        even, odd = Vector.shortEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testShortTwos(self):
-        "Test shortTwos function"
-        twos = Vector.shortTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testShortThrees(self):
-        "Test shortThrees function"
-        threes = Vector.shortThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    ######################################################
-    ### Test functions that take arrays of type USHORT ###
-    def testUshortLength(self):
-        "Test ushortLength function"
-        self.assertEquals(Vector.ushortLength([5, 12, 0]), 13)
-
-    def testUshortLengthBad(self):
-        "Test ushortLength function for wrong size"
-        self.assertRaises(TypeError, Vector.ushortLength, [5, 12])
-
-    def testUshortProd(self):
-        "Test ushortProd function"
-        self.assertEquals(Vector.ushortProd([1,2,3,4]), 24)
-
-    def testUshortProdNonContainer(self):
-        "Test ushortProd function with None"
-        self.assertRaises(TypeError, Vector.ushortProd, None)
-
-    def testUshortSum(self):
-        "Test ushortSum function"
-        self.assertEquals(Vector.ushortSum([5,6,7,8]), 26)
-
-    def testUshortReverse(self):
-        "Test ushortReverse function"
-        vector = N.array([1,2,4],'H')
-        Vector.ushortReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testUshortOnes(self):
-        "Test ushortOnes function"
-        myArray = N.zeros(5,'H')
-        Vector.ushortOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testUshortZeros(self):
-        "Test ushortZeros function"
-        myArray = N.ones(5,'H')
-        Vector.ushortZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testUshortEOSplit(self):
-        "Test ushortEOSplit function"
-        even, odd = Vector.ushortEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testUshortTwos(self):
-        "Test ushortTwos function"
-        twos = Vector.ushortTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testUshortThrees(self):
-        "Test ushortThrees function"
-        threes = Vector.ushortThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    ###################################################
-    ### Test functions that take arrays of type INT ###
-    def testIntLength(self):
-        "Test intLength function"
-        self.assertEquals(Vector.intLength([5, 12, 0]), 13)
-
-    def testIntLengthBad(self):
-        "Test intLength function for wrong size"
-        self.assertRaises(TypeError, Vector.intLength, [5, 12])
-
-    def testIntProd(self):
-        "Test intProd function"
-        self.assertEquals(Vector.intProd([1,2,3,4]), 24)
-
-    def testIntProdNonContainer(self):
-        "Test intProd function with None"
-        self.assertRaises(TypeError, Vector.intProd, None)
-
-    def testIntSum(self):
-        "Test intSum function"
-        self.assertEquals(Vector.intSum([-5,6,-7,8]), 2)
-
-    def testIntOnes(self):
-        "Test intOnes function"
-        myArray = N.zeros(5,'i')
-        Vector.intOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testIntReverse(self):
-        "Test intReverse function"
-        vector = N.array([1,2,4],'i')
-        Vector.intReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testIntZeros(self):
-        "Test intZeros function"
-        myArray = N.ones(5,'i')
-        Vector.intZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testIntEOSplit(self):
-        "Test intEOSplit function"
-        even, odd = Vector.intEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testIntTwos(self):
-        "Test intTwos function"
-        twos = Vector.intTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testIntThrees(self):
-        "Test intThrees function"
-        threes = Vector.intThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    ####################################################
-    ### Test functions that take arrays of type UINT ###
-    def testUintLength(self):
-        "Test uintLength function"
-        self.assertEquals(Vector.uintLength([5, 12, 0]), 13)
-
-    def testUintLengthBad(self):
-        "Test uintLength function for wrong size"
-
-        self.assertRaises(TypeError, Vector.uintLength, [5, 12])
-
-    def testUintProd(self):
-        "Test uintProd function"
-        self.assertEquals(Vector.uintProd([1,2,3,4]), 24)
-
-    def testUintProdNonContainer(self):
-        "Test uintProd function with None"
-        self.assertRaises(TypeError, Vector.uintProd, None)
-
-    def testUintSum(self):
-        "Test uintSum function"
-        self.assertEquals(Vector.uintSum([5,6,7,8]), 26)
-
-    def testUintReverse(self):
-        "Test uintReverse function"
-        vector = N.array([1,2,4],'I')
-        Vector.uintReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testUintOnes(self):
-        "Test uintOnes function"
-        myArray = N.zeros(5,'I')
-        Vector.uintOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testUintZeros(self):
-        "Test uintZeros function"
-        myArray = N.ones(5,'I')
-        Vector.uintZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testUintEOSplit(self):
-        "Test uintEOSplit function"
-        even, odd = Vector.uintEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testUintTwos(self):
-        "Test uintTwos function"
-        twos = Vector.uintTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testUintThrees(self):
-        "Test uintThrees function"
-        threes = Vector.uintThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    ####################################################
-    ### Test functions that take arrays of type LONG ###
-    def testLongLength(self):
-        "Test longLength function"
-        self.assertEquals(Vector.longLength([5, 12, 0]), 13)
-
-    def testLongLengthBad(self):
-        "Test longLength function for wrong size"
-        self.assertRaises(TypeError, Vector.longLength, [5, 12])
-
-    def testLongProd(self):
-        "Test longProd function"
-        self.assertEquals(Vector.longProd([1,2,3,4]), 24)
-
-    def testLongProdNonContainer(self):
-        "Test longProd function with None"
-        self.assertRaises(TypeError, Vector.longProd, None)
-
-    def testLongSum(self):
-        "Test longSum function"
-        self.assertEquals(Vector.longSum([-5,6,-7,8]), 2)
-
-    def testLongReverse(self):
-        "Test longReverse function"
-        vector = N.array([1,2,4],'l')
-        Vector.longReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testLongOnes(self):
-        "Test longOnes function"
-        myArray = N.zeros(5,'l')
-        Vector.longOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testLongZeros(self):
-        "Test longZeros function"
-        myArray = N.ones(5,'l')
-        Vector.longZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testLongEOSplit(self):
-        "Test longEOSplit function"
-        even, odd = Vector.longEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testLongTwos(self):
-        "Test longTwos function"
-        twos = Vector.longTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testLongThrees(self):
-        "Test longThrees function"
-        threes = Vector.longThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type ULONG ###
-    def testUlongLength(self):
-        "Test ulongLength function"
-        self.assertEquals(Vector.ulongLength([5, 12, 0]), 13)
-
-    def testUlongLengthBad(self):
-        "Test ulongLength function for wrong size"
-        self.assertRaises(TypeError, Vector.ulongLength, [5, 12])
-
-    def testUlongProd(self):
-        "Test ulongProd function"
-        self.assertEquals(Vector.ulongProd([1,2,3,4]), 24)
-
-    def testUlongProdNonContainer(self):
-        "Test ulongProd function with None"
-        self.assertRaises(TypeError, Vector.ulongProd, None)
-
-    def testUlongSum(self):
-        "Test ulongSum function"
-        self.assertEquals(Vector.ulongSum([5,6,7,8]), 26)
-
-    def testUlongReverse(self):
-        "Test ulongReverse function"
-        vector = N.array([1,2,4],'L')
-        Vector.ulongReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testUlongOnes(self):
-        "Test ulongOnes function"
-        myArray = N.zeros(5,'L')
-        Vector.ulongOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testUlongZeros(self):
-        "Test ulongZeros function"
-        myArray = N.ones(5,'L')
-        Vector.ulongZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testUlongEOSplit(self):
-        "Test ulongEOSplit function"
-        even, odd = Vector.ulongEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testUlongTwos(self):
-        "Test ulongTwos function"
-        twos = Vector.ulongTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testUlongThrees(self):
-        "Test ulongThrees function"
-        threes = Vector.ulongThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    ########################################################
-    ### Test functions that take arrays of type LONGLONG ###
-    def testLongLongLength(self):
-        "Test longLongLength function"
-        self.assertEquals(Vector.longLongLength([5, 12, 0]), 13)
-
-    def testLongLongLengthBad(self):
-        "Test longLongLength function for wrong size"
-        self.assertRaises(TypeError, Vector.longLongLength, [5, 12])
-
-    def testLongLongProd(self):
-        "Test longLongProd function"
-        self.assertEquals(Vector.longLongProd([1,2,3,4]), 24)
-
-    def testLongLongProdNonContainer(self):
-        "Test longLongProd function with None"
-        self.assertRaises(TypeError, Vector.longLongProd, None)
-
-    def testLongLongSum(self):
-        "Test longLongSum function"
-        self.assertEquals(Vector.longLongSum([-5,6,-7,8]), 2)
-
-    def testLongLongReverse(self):
-        "Test longLongReverse function"
-        vector = N.array([1,2,4],'q')
-        Vector.longLongReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testLongLongOnes(self):
-        "Test longLongOnes function"
-        myArray = N.zeros(5,'q')
-        Vector.longLongOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testLongLongZeros(self):
-        "Test longLongZeros function"
-        myArray = N.ones(5,'q')
-        Vector.longLongZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testLongLongEOSplit(self):
-        "Test longLongEOSplit function"
-        even, odd = Vector.longLongEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testLongLongTwos(self):
-        "Test longLongTwos function"
-        twos = Vector.longLongTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testLongLongThrees(self):
-        "Test longLongThrees function"
-        threes = Vector.longLongThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    #########################################################
-    ### Test functions that take arrays of type ULONGLONG ###
-    def testUlongLongLength(self):
-        "Test ulongLongLength function"
-        self.assertEquals(Vector.ulongLongLength([5, 12, 0]), 13)
-
-    def testUlongLongLengthBad(self):
-        "Test ulongLongLength function for wrong size"
-        self.assertRaises(TypeError, Vector.ulongLongLength, [5, 12])
-
-    def testUlonglongProd(self):
-        "Test ulongLongProd function"
-        self.assertEquals(Vector.ulongLongProd([1,2,3,4]), 24)
-
-    def testUlongLongProdNonContainer(self):
-        "Test ulongLongProd function with None"
-        self.assertRaises(TypeError, Vector.ulongLongProd, None)
-
-    def testUlongLongSum(self):
-        "Test ulongLongSum function"
-        self.assertEquals(Vector.ulongLongSum([5,6,7,8]), 26)
-
-    def testUlongLongReverse(self):
-        "Test ulongLongReverse function"
-        vector = N.array([1,2,4],'Q')
-        Vector.ulongLongReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testUlongLongOnes(self):
-        "Test ulongLongOnes function"
-        myArray = N.zeros(5,'Q')
-        Vector.ulongLongOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
-
-    def testUlongLongZeros(self):
-        "Test ulongLongZeros function"
-        myArray = N.ones(5,'Q')
-        Vector.ulongLongZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testUlongLongEOSplit(self):
-        "Test ulongLongEOSplit function"
-        even, odd = Vector.ulongLongEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testUlongLongTwos(self):
-        "Test ulongLongTwos function"
-        twos = Vector.ulongLongTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testUlongLongThrees(self):
-        "Test ulongLongThrees function"
-        threes = Vector.ulongLongThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type FLOAT ###
-    def testFloatLength(self):
-        "Test floatLength function"
-        self.assertEquals(Vector.floatLength([5, 12, 0]), 13)
-
-    def testFloatLengthBad(self):
-        "Test floatLength function for wrong size"
-        self.assertRaises(TypeError, Vector.floatLength, [5, 12])
-
-    def testFloatProd(self):
-        "Test floatProd function (to 5 decimal places)"
-        self.assertAlmostEquals(Vector.floatProd((1,2.718,3,4)), 32.616, 5)
-
-    def testFloatProdBadContainer(self):
-        "Test floatProd function with an invalid list"
-        self.assertRaises(BadListError, Vector.floatProd, [3.14, "pi"])
-
-    def testFloatSum(self):
-        "Test floatSum function"
-        self.assertEquals(Vector.floatSum([-5,6,-7,8]), 2)
-
-    def testFloatReverse(self):
-        "Test floatReverse function"
-        vector = N.array([1,2,4],'f')
-        Vector.floatReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testFloatOnes(self):
-        "Test floatOnes function"
-        myArray = N.zeros(5,'f')
-        Vector.floatOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1.,1.,1.,1.,1.]))
-
-    def testFloatOnesNonArray(self):
-        "Test floatOnes function with a list"
-        self.assertRaises(TypeError, Vector.floatOnes, [True, 0, 2.718, "pi"])
-
-    def testFloatZeros(self):
-        "Test floatZeros function"
-        myArray = N.ones(5,'f')
-        Vector.floatZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testFloatEOSplit(self):
-        "Test floatEOSplit function"
-        even, odd = Vector.floatEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testFloatTwos(self):
-        "Test floatTwos function"
-        twos = Vector.floatTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testFloatThrees(self):
-        "Test floatThrees function"
-        threes = Vector.floatThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-    ######################################################
-    ### Test functions that take arrays of type DOUBLE ###
-    def testDoubleLength(self):
-        "Test doubleLength function"
-        self.assertEquals(Vector.doubleLength([5, 12, 0]), 13)
-
-    def testDoubleLengthBad(self):
-        "Test doubleLength function for wrong size"
-        self.assertRaises(TypeError, Vector.doubleLength, [5, 12])
-
-    def testDoubleProd(self):
-        "Test doubleProd function"
-        self.assertEquals(Vector.doubleProd((1,2.718,3,4)), 32.616)
-
-    def testDoubleProdBadContainer(self):
-        "Test doubleProd function with an invalid list"
-        self.assertRaises(BadListError, Vector.doubleProd, [3.14, "pi"])
-
-    def testDoubleSum(self):
-        "Test doubleSum function"
-        self.assertEquals(Vector.doubleSum([-5,6,-7,8]), 2)
-
-    def testDoubleReverse(self):
-        "Test doubleReverse function"
-        vector = N.array([1,2,4],'d')
-        Vector.doubleReverse(vector)
-        self.assertEquals((vector == [4,2,1]).all(), True)
-
-    def testDoubleOnes(self):
-        "Test doubleOnes function"
-        myArray = N.zeros(5,'d')
-        Vector.doubleOnes(myArray)
-        N.testing.assert_array_equal(myArray, N.array([1.,1.,1.,1.,1.]))
-
-    def testDoubleOnesNonArray(self):
-        "Test doubleOnes function with a list"
-        self.assertRaises(TypeError, Vector.doubleOnes, [True, 0, 2.718, "pi"])
-
-    def testDoubleZeros(self):
-        "Test doubleZeros function"
-        myArray = N.ones(5,'d')
-        Vector.doubleZeros(myArray)
-        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
-
-    def testDoubleEOSplit(self):
-        "Test doubleEOSplit function"
-        even, odd = Vector.doubleEOSplit([1,2,3])
-        self.assertEquals((even == [1,0,3]).all(), True)
-        self.assertEquals((odd  == [0,2,0]).all(), True)
-
-    def testDoubleTwos(self):
-        "Test doubleTwos function"
-        twos = Vector.doubleTwos(5)
-        self.assertEquals((twos == [2,2,2,2,2]).all(), True)
-
-    def testDoubleThrees(self):
-        "Test doubleThrees function"
-        threes = Vector.doubleThrees(6)
-        self.assertEquals((threes == [3,3,3,3,3,3]).all(), True)
-
-######################################################################
-
-if __name__ == "__main__":
-
-    # Build the test suite
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(VectorTestCase))
-
-    # Execute the test suite
-    print "Testing 1D Functions of Module Vector"
-    print "NumPy version", N.__version__
-    print
-    result = unittest.TextTestRunner(verbosity=2).run(suite)
-    sys.exit(len(result.errors) + len(result.failures))

Deleted: trunk/numpy/doc/swig/test2D.py
===================================================================
--- trunk/numpy/doc/swig/test2D.py	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/test2D.py	2007-04-05 22:20:15 UTC (rev 3672)
@@ -1,626 +0,0 @@
-#! /usr/bin/env python
-
-# System imports
-from   distutils.util import get_platform
-import os
-import sys
-import unittest
-
-# Import NumPy
-import numpy as N
-major, minor = [ int(d) for d in N.__version__.split(".")[:2] ]
-if major == 0: BadListError = TypeError
-else:          BadListError = ValueError
-
-# Add the distutils-generated build directory to the python search path and then
-# import the extension module
-libDir = "lib.%s-%s" % (get_platform(), sys.version[:3])
-sys.path.insert(0,os.path.join("build", libDir))
-import Matrix
-
-######################################################################
-
-class MatrixTestCase(unittest.TestCase):
-
-    ####################################################
-    ### Test functions that take arrays of type BYTE ###
-    def testScharDet(self):
-        "Test scharDet function"
-        matrix = [[6,7],[8,9]]
-        self.assertEquals(Matrix.scharDet(matrix), -2)
-
-    def testScharMax(self):
-        "Test scharMax function"
-        matrix = [[-6,5,-4],[3,-2,1]]
-        self.assertEquals(Matrix.scharMax(matrix), 5)
-
-    def testScharMaxNonContainer(self):
-        "Test scharMax function with None"
-        self.assertRaises(TypeError, Matrix.scharMax, None)
-
-    def testScharMaxWrongDim(self):
-        "Test scharMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.scharMax, [0, -1, 2, -3])
-
-    def testScharMin(self):
-        "Test scharMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.scharMin(matrix), 4)
-
-    def testScharScale(self):
-        "Test scharScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'b')
-        Matrix.scharScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testScharFloor(self):
-        "Test scharFloor function"
-        matrix = N.array([[10,-2],[-6,7]],'b')
-        Matrix.scharFloor(matrix,0)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
-
-    def testScharCeil(self):
-        "Test scharCeil function"
-        matrix = N.array([[10,-2],[-6,7]],'b')
-        Matrix.scharCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
-
-    def testScharLUSplit(self):
-        "Test scharLUSplit function"
-        lower, upper = Matrix.scharLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type UBYTE ###
-    def testUcharDet(self):
-        "Test ucharDet function"
-        matrix = [[7,6],[9,8]]
-        self.assertEquals(Matrix.ucharDet(matrix), 2)
-
-    def testUcharMax(self):
-        "Test ucharMax function"
-        matrix = [[6,5,4],[3,2,1]]
-        self.assertEquals(Matrix.ucharMax(matrix), 6)
-
-    def testUcharMaxNonContainer(self):
-        "Test ucharMax function with None"
-        self.assertRaises(TypeError, Matrix.ucharMax, None)
-
-    def testUcharMaxWrongDim(self):
-        "Test ucharMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.ucharMax, [0, 1, 2, 3])
-
-    def testUcharMin(self):
-        "Test ucharMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.ucharMin(matrix), 4)
-
-    def testUcharScale(self):
-        "Test ucharScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'B')
-        Matrix.ucharScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testUcharFloor(self):
-        "Test ucharFloor function"
-        matrix = N.array([[10,2],[6,7]],'B')
-        Matrix.ucharFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
-
-    def testUcharCeil(self):
-        "Test ucharCeil function"
-        matrix = N.array([[10,2],[6,7]],'B')
-        Matrix.ucharCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
-
-    def testUcharLUSplit(self):
-        "Test ucharLUSplit function"
-        lower, upper = Matrix.ucharLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type SHORT ###
-    def testShortDet(self):
-        "Test shortDet function"
-        matrix = [[6,7],[8,9]]
-        self.assertEquals(Matrix.shortDet(matrix), -2)
-
-    def testShortMax(self):
-        "Test shortMax function"
-        matrix = [[-6,5,-4],[3,-2,1]]
-        self.assertEquals(Matrix.shortMax(matrix), 5)
-
-    def testShortMaxNonContainer(self):
-        "Test shortMax function with None"
-        self.assertRaises(TypeError, Matrix.shortMax, None)
-
-    def testShortMaxWrongDim(self):
-        "Test shortMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.shortMax, [0, -1, 2, -3])
-
-    def testShortMin(self):
-        "Test shortMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.shortMin(matrix), 4)
-
-    def testShortScale(self):
-        "Test shortScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'h')
-        Matrix.shortScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testShortFloor(self):
-        "Test shortFloor function"
-        matrix = N.array([[10,-2],[-6,7]],'h')
-        Matrix.shortFloor(matrix,0)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
-
-    def testShortCeil(self):
-        "Test shortCeil function"
-        matrix = N.array([[10,-2],[-6,7]],'h')
-        Matrix.shortCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
-
-    def testShortLUSplit(self):
-        "Test shortLUSplit function"
-        lower, upper = Matrix.shortLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    ######################################################
-    ### Test functions that take arrays of type USHORT ###
-    def testUshortDet(self):
-        "Test ushortDet function"
-        matrix = [[7,6],[9,8]]
-        self.assertEquals(Matrix.ushortDet(matrix), 2)
-
-    def testUshortMax(self):
-        "Test ushortMax function"
-        matrix = [[6,5,4],[3,2,1]]
-        self.assertEquals(Matrix.ushortMax(matrix), 6)
-
-    def testUshortMaxNonContainer(self):
-        "Test ushortMax function with None"
-        self.assertRaises(TypeError, Matrix.ushortMax, None)
-
-    def testUshortMaxWrongDim(self):
-        "Test ushortMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.ushortMax, [0, 1, 2, 3])
-
-    def testUshortMin(self):
-        "Test ushortMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.ushortMin(matrix), 4)
-
-    def testUshortScale(self):
-        "Test ushortScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'H')
-        Matrix.ushortScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testUshortFloor(self):
-        "Test ushortFloor function"
-        matrix = N.array([[10,2],[6,7]],'H')
-        Matrix.ushortFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
-
-    def testUshortCeil(self):
-        "Test ushortCeil function"
-        matrix = N.array([[10,2],[6,7]],'H')
-        Matrix.ushortCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
-
-    def testUshortLUSplit(self):
-        "Test ushortLUSplit function"
-        lower, upper = Matrix.ushortLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    ###################################################
-    ### Test functions that take arrays of type INT ###
-    def testIntDet(self):
-        "Test intDet function"
-        matrix = [[6,7],[8,9]]
-        self.assertEquals(Matrix.intDet(matrix), -2)
-
-    def testIntMax(self):
-        "Test intMax function"
-        matrix = [[-6,5,-4],[3,-2,1]]
-        self.assertEquals(Matrix.intMax(matrix), 5)
-
-    def testIntMaxNonContainer(self):
-        "Test intMax function with None"
-        self.assertRaises(TypeError, Matrix.intMax, None)
-
-    def testIntMaxWrongDim(self):
-        "Test intMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.intMax, [0, -1, 2, -3])
-
-    def testIntMin(self):
-        "Test intMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.intMin(matrix), 4)
-
-    def testIntScale(self):
-        "Test intScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'i')
-        Matrix.intScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testIntFloor(self):
-        "Test intFloor function"
-        matrix = N.array([[10,-2],[-6,7]],'i')
-        Matrix.intFloor(matrix,0)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
-
-    def testIntCeil(self):
-        "Test intCeil function"
-        matrix = N.array([[10,-2],[-6,7]],'i')
-        Matrix.intCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
-
-    def testIntLUSplit(self):
-        "Test intLUSplit function"
-        lower, upper = Matrix.intLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    ####################################################
-    ### Test functions that take arrays of type UINT ###
-    def testUintDet(self):
-        "Test uintDet function"
-        matrix = [[7,6],[9,8]]
-        self.assertEquals(Matrix.uintDet(matrix), 2)
-
-    def testUintMax(self):
-        "Test uintMax function"
-        matrix = [[6,5,4],[3,2,1]]
-        self.assertEquals(Matrix.uintMax(matrix), 6)
-
-    def testUintMaxNonContainer(self):
-        "Test uintMax function with None"
-        self.assertRaises(TypeError, Matrix.uintMax, None)
-
-    def testUintMaxWrongDim(self):
-        "Test uintMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.uintMax, [0, 1, 2, 3])
-
-    def testUintMin(self):
-        "Test uintMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.uintMin(matrix), 4)
-
-    def testUintScale(self):
-        "Test uintScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'I')
-        Matrix.uintScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testUintFloor(self):
-        "Test uintFloor function"
-        matrix = N.array([[10,2],[6,7]],'I')
-        Matrix.uintFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
-
-    def testUintCeil(self):
-        "Test uintCeil function"
-        matrix = N.array([[10,2],[6,7]],'I')
-        Matrix.uintCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
-
-    def testUintLUSplit(self):
-        "Test uintLUSplit function"
-        lower, upper = Matrix.uintLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    ####################################################
-    ### Test functions that take arrays of type LONG ###
-    def testLongDet(self):
-        "Test longDet function"
-        matrix = [[6,7],[8,9]]
-        self.assertEquals(Matrix.longDet(matrix), -2)
-
-    def testLongMax(self):
-        "Test longMax function"
-        matrix = [[-6,5,-4],[3,-2,1]]
-        self.assertEquals(Matrix.longMax(matrix), 5)
-
-    def testLongMaxNonContainer(self):
-        "Test longMax function with None"
-        self.assertRaises(TypeError, Matrix.longMax, None)
-
-    def testLongMaxWrongDim(self):
-        "Test longMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.longMax, [0, -1, 2, -3])
-
-    def testLongMin(self):
-        "Test longMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.longMin(matrix), 4)
-
-    def testLongScale(self):
-        "Test longScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'l')
-        Matrix.longScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testLongFloor(self):
-        "Test longFloor function"
-        matrix = N.array([[10,-2],[-6,7]],'l')
-        Matrix.longFloor(matrix,0)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
-
-    def testLongCeil(self):
-        "Test longCeil function"
-        matrix = N.array([[10,-2],[-6,7]],'l')
-        Matrix.longCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
-
-    def testLongLUSplit(self):
-        "Test longLUSplit function"
-        lower, upper = Matrix.longLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type ULONG ###
-    def testUlongDet(self):
-        "Test ulongDet function"
-        matrix = [[7,6],[9,8]]
-        self.assertEquals(Matrix.ulongDet(matrix), 2)
-
-    def testUlongMax(self):
-        "Test ulongMax function"
-        matrix = [[6,5,4],[3,2,1]]
-        self.assertEquals(Matrix.ulongMax(matrix), 6)
-
-    def testUlongMaxNonContainer(self):
-        "Test ulongMax function with None"
-        self.assertRaises(TypeError, Matrix.ulongMax, None)
-
-    def testUlongMaxWrongDim(self):
-        "Test ulongMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.ulongMax, [0, 1, 2, 3])
-
-    def testUlongMin(self):
-        "Test ulongMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.ulongMin(matrix), 4)
-
-    def testUlongScale(self):
-        "Test ulongScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'L')
-        Matrix.ulongScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testUlongFloor(self):
-        "Test ulongFloor function"
-        matrix = N.array([[10,2],[6,7]],'L')
-        Matrix.ulongFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
-
-    def testUlongCeil(self):
-        "Test ulongCeil function"
-        matrix = N.array([[10,2],[6,7]],'L')
-        Matrix.ulongCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
-
-    def testUlongLUSplit(self):
-        "Test ulongLUSplit function"
-        lower, upper = Matrix.ulongLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    ########################################################
-    ### Test functions that take arrays of type LONGLONG ###
-    def testLongLongDet(self):
-        "Test longLongDet function"
-        matrix = [[6,7],[8,9]]
-        self.assertEquals(Matrix.longLongDet(matrix), -2)
-
-    def testLongLongMax(self):
-        "Test longLongMax function"
-        matrix = [[-6,5,-4],[3,-2,1]]
-        self.assertEquals(Matrix.longLongMax(matrix), 5)
-
-    def testLongLongMaxNonContainer(self):
-        "Test longLongMax function with None"
-        self.assertRaises(TypeError, Matrix.longLongMax, None)
-
-    def testLongLongMaxWrongDim(self):
-        "Test longLongMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.longLongMax, [0, -1, 2, -3])
-
-    def testLongLongMin(self):
-        "Test longLongMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.longLongMin(matrix), 4)
-
-    def testLongLongScale(self):
-        "Test longLongScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'q')
-        Matrix.longLongScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testLongLongFloor(self):
-        "Test longLongFloor function"
-        matrix = N.array([[10,-2],[-6,7]],'q')
-        Matrix.longLongFloor(matrix,0)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
-
-    def testLongLongCeil(self):
-        "Test longLongCeil function"
-        matrix = N.array([[10,-2],[-6,7]],'q')
-        Matrix.longLongCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
-
-    def testLongLongLUSplit(self):
-        "Test longLongLUSplit function"
-        lower, upper = Matrix.longLongLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    #########################################################
-    ### Test functions that take arrays of type ULONGLONG ###
-    def testUlongLongDet(self):
-        "Test ulongLongDet function"
-        matrix = [[7,6],[9,8]]
-        self.assertEquals(Matrix.ulongLongDet(matrix), 2)
-
-    def testUlongLongMax(self):
-        "Test ulongLongMax function"
-        matrix = [[6,5,4],[3,2,1]]
-        self.assertEquals(Matrix.ulongLongMax(matrix), 6)
-
-    def testUlongLongMaxNonContainer(self):
-        "Test ulongLongMax function with None"
-        self.assertRaises(TypeError, Matrix.ulongLongMax, None)
-
-    def testUlongLongMaxWrongDim(self):
-        "Test ulongLongMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.ulongLongMax, [0, 1, 2, 3])
-
-    def testUlongLongMin(self):
-        "Test ulongLongMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.ulongLongMin(matrix), 4)
-
-    def testUlongLongScale(self):
-        "Test ulongLongScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'Q')
-        Matrix.ulongLongScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testUlongLongFloor(self):
-        "Test ulongLongFloor function"
-        matrix = N.array([[10,2],[6,7]],'Q')
-        Matrix.ulongLongFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
-
-    def testUlongLongCeil(self):
-        "Test ulongLongCeil function"
-        matrix = N.array([[10,2],[6,7]],'Q')
-        Matrix.ulongLongCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
-
-    def testUlongLongLUSplit(self):
-        "Test ulongLongLUSplit function"
-        lower, upper = Matrix.ulongLongLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type FLOAT ###
-    def testFloatDet(self):
-        "Test floatDet function"
-        matrix = [[6,7],[8,9]]
-        self.assertEquals(Matrix.floatDet(matrix), -2)
-
-    def testFloatMax(self):
-        "Test floatMax function"
-        matrix = [[-6,5,-4],[3.14,-2.718,1]]
-        self.assertEquals(Matrix.floatMax(matrix), 5.0)
-
-    def testFloatMaxNonContainer(self):
-        "Test floatMax function with None"
-        self.assertRaises(TypeError, Matrix.floatMax, None)
-
-    def testFloatMaxWrongDim(self):
-        "Test floatMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.floatMax, [0.0, -1, 2.718, -3.14])
-
-    def testFloatMin(self):
-        "Test floatMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.floatMin(matrix), 4)
-
-    def testFloatScale(self):
-        "Test floatScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'f')
-        Matrix.floatScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testFloatFloor(self):
-        "Test floatFloor function"
-        matrix = N.array([[10,-2],[-6,7]],'f')
-        Matrix.floatFloor(matrix,0)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
-
-    def testFloatCeil(self):
-        "Test floatCeil function"
-        matrix = N.array([[10,-2],[-6,7]],'f')
-        Matrix.floatCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
-
-    def testFloatLUSplit(self):
-        "Test floatLUSplit function"
-        lower, upper = Matrix.floatLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-    ######################################################
-    ### Test functions that take arrays of type DOUBLE ###
-    def testDoubleDet(self):
-        "Test doubleDet function"
-        matrix = [[6,7],[8,9]]
-        self.assertEquals(Matrix.doubleDet(matrix), -2)
-
-    def testDoubleMax(self):
-        "Test doubleMax function"
-        matrix = [[-6,5,-4],[3.14,-2.718,1]]
-        self.assertEquals(Matrix.doubleMax(matrix), 5.0)
-
-    def testDoubleMaxNonContainer(self):
-        "Test doubleMax function with None"
-        self.assertRaises(TypeError, Matrix.doubleMax, None)
-
-    def testDoubleMaxWrongDim(self):
-        "Test doubleMax function with a 1D array"
-        self.assertRaises(TypeError, Matrix.doubleMax, [0.0, -1, 2.718, -3.14])
-
-    def testDoubleMin(self):
-        "Test doubleMin function"
-        matrix = [[9,8],[7,6],[5,4]]
-        self.assertEquals(Matrix.doubleMin(matrix), 4)
-
-    def testDoubleScale(self):
-        "Test doubleScale function"
-        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],'d')
-        Matrix.doubleScale(matrix,4)
-        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
-
-    def testDoubleFloor(self):
-        "Test doubleFloor function"
-        matrix = N.array([[10,-2],[-6,7]],'d')
-        Matrix.doubleFloor(matrix,0)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
-
-    def testDoubleCeil(self):
-        "Test doubleCeil function"
-        matrix = N.array([[10,-2],[-6,7]],'d')
-        Matrix.doubleCeil(matrix,5)
-        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
-
-    def testDoubleLUSplit(self):
-        "Test doubleLUSplit function"
-        lower, upper = Matrix.doubleLUSplit([[1,2,3],[4,5,6],[7,8,9]])
-        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
-        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
-
-######################################################################
-
-if __name__ == "__main__":
-
-    # Build the test suite
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(MatrixTestCase))
-
-    # Execute the test suite
-    print "Testing 2D Functions of Module Matrix"
-    print "NumPy version", N.__version__
-    print
-    result = unittest.TextTestRunner(verbosity=2).run(suite)
-    sys.exit(len(result.errors) + len(result.failures))

Deleted: trunk/numpy/doc/swig/test3D.py
===================================================================
--- trunk/numpy/doc/swig/test3D.py	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/test3D.py	2007-04-05 22:20:15 UTC (rev 3672)
@@ -1,795 +0,0 @@
-#! /usr/bin/env python
-
-# System imports
-from   distutils.util import get_platform
-import os
-import sys
-import unittest
-
-# Import NumPy
-import numpy as N
-major, minor = [ int(d) for d in N.__version__.split(".")[:2] ]
-if major == 0: BadListError = TypeError
-else:          BadListError = ValueError
-
-# Add the distutils-generated build directory to the python search path and then
-# import the extension module
-libDir = "lib.%s-%s" % (get_platform(), sys.version[:3])
-sys.path.insert(0,os.path.join("build", libDir))
-import Tensor
-
-######################################################################
-
-class TensorTestCase(unittest.TestCase):
-
-    ####################################################
-    ### Test functions that take arrays of type BYTE ###
-    def testScharNorm(self):
-        "Test scharNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.scharNorm(tensor), 1)
-
-    def testScharMax(self):
-        "Test scharMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.scharMax(tensor), 8)
-
-    def testScharMaxNonContainer(self):
-        "Test scharMax function with None"
-        self.assertRaises(TypeError, Tensor.scharMax, None)
-
-    def testScharMaxWrongDim(self):
-        "Test scharMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.scharMax, [0, -1, 2, -3])
-
-    def testScharMin(self):
-        "Test scharMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.scharMin(tensor), 2)
-
-    def testScharScale(self):
-        "Test scharScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'b')
-        Tensor.scharScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testScharFloor(self):
-        "Test scharFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'b')
-        Tensor.scharFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testScharCeil(self):
-        "Test scharCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'b')
-        Tensor.scharCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testScharLUSplit(self):
-        "Test scharLUSplit function"
-        lower, upper = Tensor.scharLUSplit([[[1,1], [1,1]],
-                                            [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type UBYTE ###
-    def testUcharNorm(self):
-        "Test ucharNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.ucharNorm(tensor), 1)
-
-    def testUcharMax(self):
-        "Test ucharMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.ucharMax(tensor), 8)
-
-    def testUcharMaxNonContainer(self):
-        "Test ucharMax function with None"
-        self.assertRaises(TypeError, Tensor.ucharMax, None)
-
-    def testUcharMaxWrongDim(self):
-        "Test ucharMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.ucharMax, [0, -1, 2, -3])
-
-    def testUcharMin(self):
-        "Test ucharMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.ucharMin(tensor), 2)
-
-    def testUcharScale(self):
-        "Test ucharScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'B')
-        Tensor.ucharScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testUcharFloor(self):
-        "Test ucharFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'B')
-        Tensor.ucharFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testUcharCeil(self):
-        "Test ucharCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'B')
-        Tensor.ucharCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testUcharLUSplit(self):
-        "Test ucharLUSplit function"
-        lower, upper = Tensor.ucharLUSplit([[[1,1], [1,1]],
-                                            [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type SHORT ###
-    def testShortNorm(self):
-        "Test shortNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.shortNorm(tensor), 1)
-
-    def testShortMax(self):
-        "Test shortMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.shortMax(tensor), 8)
-
-    def testShortMaxNonContainer(self):
-        "Test shortMax function with None"
-        self.assertRaises(TypeError, Tensor.shortMax, None)
-
-    def testShortMaxWrongDim(self):
-        "Test shortMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.shortMax, [0, -1, 2, -3])
-
-    def testShortMin(self):
-        "Test shortMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.shortMin(tensor), 2)
-
-    def testShortScale(self):
-        "Test shortScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'h')
-        Tensor.shortScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testShortFloor(self):
-        "Test shortFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'h')
-        Tensor.shortFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testShortCeil(self):
-        "Test shortCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'h')
-        Tensor.shortCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testShortLUSplit(self):
-        "Test shortLUSplit function"
-        lower, upper = Tensor.shortLUSplit([[[1,1], [1,1]],
-                                            [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    ######################################################
-    ### Test functions that take arrays of type USHORT ###
-    def testUshortNorm(self):
-        "Test ushortNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.ushortNorm(tensor), 1)
-
-    def testUshortMax(self):
-        "Test ushortMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.ushortMax(tensor), 8)
-
-    def testUshortMaxNonContainer(self):
-        "Test ushortMax function with None"
-        self.assertRaises(TypeError, Tensor.ushortMax, None)
-
-    def testUshortMaxWrongDim(self):
-        "Test ushortMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.ushortMax, [0, -1, 2, -3])
-
-    def testUshortMin(self):
-        "Test ushortMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.ushortMin(tensor), 2)
-
-    def testUshortScale(self):
-        "Test ushortScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'H')
-        Tensor.ushortScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testUshortFloor(self):
-        "Test ushortFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'H')
-        Tensor.ushortFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testUshortCeil(self):
-        "Test ushortCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'H')
-        Tensor.ushortCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testUshortLUSplit(self):
-        "Test ushortLUSplit function"
-        lower, upper = Tensor.ushortLUSplit([[[1,1], [1,1]],
-                                             [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    ###################################################
-    ### Test functions that take arrays of type INT ###
-    def testIntNorm(self):
-        "Test intNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.intNorm(tensor), 1)
-
-    def testIntMax(self):
-        "Test intMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.intMax(tensor), 8)
-
-    def testIntMaxNonContainer(self):
-        "Test intMax function with None"
-        self.assertRaises(TypeError, Tensor.intMax, None)
-
-    def testIntMaxWrongDim(self):
-        "Test intMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.intMax, [0, -1, 2, -3])
-
-    def testIntMin(self):
-        "Test intMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.intMin(tensor), 2)
-
-    def testIntScale(self):
-        "Test intScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'i')
-        Tensor.intScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testIntFloor(self):
-        "Test intFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'i')
-        Tensor.intFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testIntCeil(self):
-        "Test intCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'i')
-        Tensor.intCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testIntLUSplit(self):
-        "Test intLUSplit function"
-        lower, upper = Tensor.intLUSplit([[[1,1], [1,1]],
-                                          [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    ####################################################
-    ### Test functions that take arrays of type UINT ###
-    def testUintNorm(self):
-        "Test uintNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.uintNorm(tensor), 1)
-
-    def testUintMax(self):
-        "Test uintMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.uintMax(tensor), 8)
-
-    def testUintMaxNonContainer(self):
-        "Test uintMax function with None"
-        self.assertRaises(TypeError, Tensor.uintMax, None)
-
-    def testUintMaxWrongDim(self):
-        "Test uintMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.uintMax, [0, -1, 2, -3])
-
-    def testUintMin(self):
-        "Test uintMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.uintMin(tensor), 2)
-
-    def testUintScale(self):
-        "Test uintScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'I')
-        Tensor.uintScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testUintFloor(self):
-        "Test uintFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'I')
-        Tensor.uintFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testUintCeil(self):
-        "Test uintCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'I')
-        Tensor.uintCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testUintLUSplit(self):
-        "Test uintLUSplit function"
-        lower, upper = Tensor.uintLUSplit([[[1,1], [1,1]],
-                                           [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    ####################################################
-    ### Test functions that take arrays of type LONG ###
-    def testLongNorm(self):
-        "Test longNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.longNorm(tensor), 1)
-
-    def testLongMax(self):
-        "Test longMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.longMax(tensor), 8)
-
-    def testLongMaxNonContainer(self):
-        "Test longMax function with None"
-        self.assertRaises(TypeError, Tensor.longMax, None)
-
-    def testLongMaxWrongDim(self):
-        "Test longMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.longMax, [0, -1, 2, -3])
-
-    def testLongMin(self):
-        "Test longMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.longMin(tensor), 2)
-
-    def testLongScale(self):
-        "Test longScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'l')
-        Tensor.longScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testLongFloor(self):
-        "Test longFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'l')
-        Tensor.longFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testLongCeil(self):
-        "Test longCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'l')
-        Tensor.longCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testLongLUSplit(self):
-        "Test longLUSplit function"
-        lower, upper = Tensor.longLUSplit([[[1,1], [1,1]],
-                                           [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type ULONG ###
-    def testUlongNorm(self):
-        "Test ulongNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.ulongNorm(tensor), 1)
-
-    def testUlongMax(self):
-        "Test ulongMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.ulongMax(tensor), 8)
-
-    def testUlongMaxNonContainer(self):
-        "Test ulongMax function with None"
-        self.assertRaises(TypeError, Tensor.ulongMax, None)
-
-    def testUlongMaxWrongDim(self):
-        "Test ulongMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.ulongMax, [0, -1, 2, -3])
-
-    def testUlongMin(self):
-        "Test ulongMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.ulongMin(tensor), 2)
-
-    def testUlongScale(self):
-        "Test ulongScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'L')
-        Tensor.ulongScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testUlongFloor(self):
-        "Test ulongFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'L')
-        Tensor.ulongFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testUlongCeil(self):
-        "Test ulongCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'L')
-        Tensor.ulongCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testUlongLUSplit(self):
-        "Test ulongLUSplit function"
-        lower, upper = Tensor.ulongLUSplit([[[1,1], [1,1]],
-                                            [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    ########################################################
-    ### Test functions that take arrays of type LONGLONG ###
-    def testLongLongNorm(self):
-        "Test longLongNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.longLongNorm(tensor), 1)
-
-    def testLongLongMax(self):
-        "Test longLongMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.longLongMax(tensor), 8)
-
-    def testLongLongMaxNonContainer(self):
-        "Test longLongMax function with None"
-        self.assertRaises(TypeError, Tensor.longLongMax, None)
-
-    def testLongLongMaxWrongDim(self):
-        "Test longLongMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.longLongMax, [0, -1, 2, -3])
-
-    def testLongLongMin(self):
-        "Test longLongMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.longLongMin(tensor), 2)
-
-    def testLongLongScale(self):
-        "Test longLongScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'q')
-        Tensor.longLongScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testLongLongFloor(self):
-        "Test longLongFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'q')
-        Tensor.longLongFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testLongLongCeil(self):
-        "Test longLongCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'q')
-        Tensor.longLongCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testLongLongLUSplit(self):
-        "Test longLongLUSplit function"
-        lower, upper = Tensor.longLongLUSplit([[[1,1], [1,1]],
-                                               [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    #########################################################
-    ### Test functions that take arrays of type ULONGLONG ###
-    def testUlongLongNorm(self):
-        "Test ulongLongNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertEquals(Tensor.ulongLongNorm(tensor), 1)
-
-    def testUlongLongMax(self):
-        "Test ulongLongMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.ulongLongMax(tensor), 8)
-
-    def testUlongLongMaxNonContainer(self):
-        "Test ulongLongMax function with None"
-        self.assertRaises(TypeError, Tensor.ulongLongMax, None)
-
-    def testUlongLongMaxWrongDim(self):
-        "Test ulongLongMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.ulongLongMax, [0, -1, 2, -3])
-
-    def testUlongLongMin(self):
-        "Test ulongLongMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.ulongLongMin(tensor), 2)
-
-    def testUlongLongScale(self):
-        "Test ulongLongScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'Q')
-        Tensor.ulongLongScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testUlongLongFloor(self):
-        "Test ulongLongFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'Q')
-        Tensor.ulongLongFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testUlongLongCeil(self):
-        "Test ulongLongCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'Q')
-        Tensor.ulongLongCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testUlongLongLUSplit(self):
-        "Test ulongLongLUSplit function"
-        lower, upper = Tensor.ulongLongLUSplit([[[1,1], [1,1]],
-                                                [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    #####################################################
-    ### Test functions that take arrays of type FLOAT ###
-    def testFloatNorm(self):
-        "Test floatNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertAlmostEquals(Tensor.floatNorm(tensor), 1.870828, 5)
-        # 1.8708286933869707
-
-    def testFloatMax(self):
-        "Test floatMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.floatMax(tensor), 8)
-
-    def testFloatMaxNonContainer(self):
-        "Test floatMax function with None"
-        self.assertRaises(TypeError, Tensor.floatMax, None)
-
-    def testFloatMaxWrongDim(self):
-        "Test floatMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.floatMax, [0, -1, 2, -3])
-
-    def testFloatMin(self):
-        "Test floatMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.floatMin(tensor), 2)
-
-    def testFloatScale(self):
-        "Test floatScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'f')
-        Tensor.floatScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testFloatFloor(self):
-        "Test floatFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'f')
-        Tensor.floatFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testFloatCeil(self):
-        "Test floatCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'f')
-        Tensor.floatCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testFloatLUSplit(self):
-        "Test floatLUSplit function"
-        lower, upper = Tensor.floatLUSplit([[[1,1], [1,1]],
-                                            [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-    ######################################################
-    ### Test functions that take arrays of type DOUBLE ###
-    def testDoubleNorm(self):
-        "Test doubleNorm function"
-        tensor = [[[0,1], [2,3]],
-                  [[3,2], [1,0]]]
-        self.assertAlmostEquals(Tensor.doubleNorm(tensor), 1.8708286933869)
-
-    def testDoubleMax(self):
-        "Test doubleMax function"
-        tensor = [[[1,2], [3,4]],
-                  [[5,6], [7,8]]]
-        self.assertEquals(Tensor.doubleMax(tensor), 8)
-
-    def testDoubleMaxNonContainer(self):
-        "Test doubleMax function with None"
-        self.assertRaises(TypeError, Tensor.doubleMax, None)
-
-    def testDoubleMaxWrongDim(self):
-        "Test doubleMax function with a 1D array"
-        self.assertRaises(TypeError, Tensor.doubleMax, [0, -1, 2, -3])
-
-    def testDoubleMin(self):
-        "Test doubleMin function"
-        tensor = [[[9,8], [7,6]],
-                  [[5,4], [3,2]]]
-        self.assertEquals(Tensor.doubleMin(tensor), 2)
-
-    def testDoubleScale(self):
-        "Test doubleScale function"
-        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
-                          [[0,1,0], [1,0,1], [0,1,0]],
-                          [[1,0,1], [0,1,0], [1,0,1]]],'d')
-        Tensor.doubleScale(tensor,4)
-        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
-                                      [[0,4,0], [4,0,4], [0,4,0]],
-                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
-
-    def testDoubleFloor(self):
-        "Test doubleFloor function"
-        tensor = N.array([[[1,2], [3,4]],
-                          [[5,6], [7,8]]],'d')
-        Tensor.doubleFloor(tensor,4)
-        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
-                                                      [[5,6], [7,8]]]))
-
-    def testDoubleCeil(self):
-        "Test doubleCeil function"
-        tensor = N.array([[[9,8], [7,6]],
-                          [[5,4], [3,2]]],'d')
-        Tensor.doubleCeil(tensor,5)
-        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
-                                                      [[5,4], [3,2]]]))
-
-    def testDoubleLUSplit(self):
-        "Test doubleLUSplit function"
-        lower, upper = Tensor.doubleLUSplit([[[1,1], [1,1]],
-                                             [[1,1], [1,1]]])
-        self.assertEquals((lower == [[[1,1], [1,0]],
-                                     [[1,0], [0,0]]]).all(), True)
-        self.assertEquals((upper == [[[0,0], [0,1]],
-                                     [[0,1], [1,1]]]).all(), True)
-
-######################################################################
-
-if __name__ == "__main__":
-
-    # Build the test suite
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.makeSuite(TensorTestCase))
-
-    # Execute the test suite
-    print "Testing 3D Functions of Module Tensor"
-    print "NumPy version", N.__version__
-    print
-    result = unittest.TextTestRunner(verbosity=2).run(suite)
-    sys.exit(len(result.errors) + len(result.failures))

Added: trunk/numpy/doc/swig/testMatrix.py
===================================================================
--- trunk/numpy/doc/swig/testMatrix.py	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/testMatrix.py	2007-04-05 22:20:15 UTC (rev 3672)
@@ -0,0 +1,215 @@
+#! /usr/bin/env python
+
+# System imports
+from   distutils.util import get_platform
+import os
+import sys
+import unittest
+
+# Import NumPy
+import numpy as N
+major, minor = [ int(d) for d in N.__version__.split(".")[:2] ]
+if major == 0: BadListError = TypeError
+else:          BadListError = ValueError
+
+# Add the distutils-generated build directory to the python search path and then
+# import the extension module
+libDir = "lib.%s-%s" % (get_platform(), sys.version[:3])
+sys.path.insert(0,os.path.join("build", libDir))
+import Matrix
+
+######################################################################
+
+class MatrixTestCase(unittest.TestCase):
+
+    def __init__(self, methodName="runTests"):
+        unittest.TestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+
+    def testDet(self):
+        "Test det function"
+        print >>sys.stderr, self.typeStr, "... ",
+        det = Matrix.__dict__[self.typeStr + "Det"]
+        matrix = [[8,7],[6,9]]
+        self.assertEquals(det(matrix), 30)
+
+    def testMax(self):
+        "Test max function"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = Matrix.__dict__[self.typeStr + "Max"]
+        matrix = [[6,5,4],[3,2,1]]
+        self.assertEquals(max(matrix), 6)
+
+    def testMaxNonContainer(self):
+        "Test max function with None"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = Matrix.__dict__[self.typeStr + "Max"]
+        self.assertRaises(TypeError, max, None)
+
+    def testMaxWrongDim(self):
+        "Test max function with a 1D array"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = Matrix.__dict__[self.typeStr + "Max"]
+        self.assertRaises(TypeError, max, [0, 1, 2, 3])
+
+    def testMin(self):
+        "Test min function"
+        print >>sys.stderr, self.typeStr, "... ",
+        min = Matrix.__dict__[self.typeStr + "Min"]
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(min(matrix), 4)
+
+    def testScale(self):
+        "Test scale function"
+        print >>sys.stderr, self.typeStr, "... ",
+        scale = Matrix.__dict__[self.typeStr + "Scale"]
+        matrix = N.array([[1,2,3],[2,1,2],[3,2,1]],self.typeCode)
+        scale(matrix,4)
+        self.assertEquals((matrix == [[4,8,12],[8,4,8],[12,8,4]]).all(), True)
+
+    def testFloor(self):
+        "Test floor function"
+        print >>sys.stderr, self.typeStr, "... ",
+        floor = Matrix.__dict__[self.typeStr + "Floor"]
+        matrix = N.array([[6,7],[8,9]],self.typeCode)
+        floor(matrix,7)
+        N.testing.assert_array_equal(matrix, N.array([[7,7],[8,9]]))
+
+    def testCeil(self):
+        "Test ceil function"
+        print >>sys.stderr, self.typeStr, "... ",
+        ceil = Matrix.__dict__[self.typeStr + "Ceil"]
+        matrix = N.array([[1,2],[3,4]],self.typeCode)
+        ceil(matrix,3)
+        N.testing.assert_array_equal(matrix, N.array([[1,2],[3,3]]))
+
+    def testLUSplit(self):
+        "Test luSplit function"
+        print >>sys.stderr, self.typeStr, "... ",
+        luSplit = Matrix.__dict__[self.typeStr + "LUSplit"]
+        lower, upper = luSplit([[1,2,3],[4,5,6],[7,8,9]])
+        self.assertEquals((lower == [[1,0,0],[4,5,0],[7,8,9]]).all(), True)
+        self.assertEquals((upper == [[0,2,3],[0,0,6],[0,0,0]]).all(), True)
+
+######################################################################
+
+class scharTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "schar"
+        self.typeCode = "b"
+
+######################################################################
+
+class ucharTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "uchar"
+        self.typeCode = "B"
+
+######################################################################
+
+class shortTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "short"
+        self.typeCode = "h"
+
+######################################################################
+
+class ushortTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "ushort"
+        self.typeCode = "H"
+
+######################################################################
+
+class intTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "int"
+        self.typeCode = "i"
+
+######################################################################
+
+class uintTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "uint"
+        self.typeCode = "I"
+
+######################################################################
+
+class longTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "long"
+        self.typeCode = "l"
+
+######################################################################
+
+class ulongTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "ulong"
+        self.typeCode = "L"
+
+######################################################################
+
+class longLongTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "longLong"
+        self.typeCode = "q"
+
+######################################################################
+
+class ulongLongTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "ulongLong"
+        self.typeCode = "Q"
+
+######################################################################
+
+class floatTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "float"
+        self.typeCode = "f"
+
+######################################################################
+
+class doubleTestCase(MatrixTestCase):
+    def __init__(self, methodName="runTest"):
+        MatrixTestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+
+######################################################################
+
+if __name__ == "__main__":
+
+    # Build the test suite
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(    scharTestCase))
+    suite.addTest(unittest.makeSuite(    ucharTestCase))
+    suite.addTest(unittest.makeSuite(    shortTestCase))
+    suite.addTest(unittest.makeSuite(   ushortTestCase))
+    suite.addTest(unittest.makeSuite(      intTestCase))
+    suite.addTest(unittest.makeSuite(     uintTestCase))
+    suite.addTest(unittest.makeSuite(     longTestCase))
+    suite.addTest(unittest.makeSuite(    ulongTestCase))
+    suite.addTest(unittest.makeSuite( longLongTestCase))
+    suite.addTest(unittest.makeSuite(ulongLongTestCase))
+    suite.addTest(unittest.makeSuite(    floatTestCase))
+    suite.addTest(unittest.makeSuite(   doubleTestCase))
+
+    # Execute the test suite
+    print "Testing 2D Functions of Module Matrix"
+    print "NumPy version", N.__version__
+    print
+    result = unittest.TextTestRunner(verbosity=2).run(suite)
+    sys.exit(len(result.errors) + len(result.failures))


Property changes on: trunk/numpy/doc/swig/testMatrix.py
___________________________________________________________________
Name: svn:executable
   + *

Added: trunk/numpy/doc/swig/testTensor.py
===================================================================
--- trunk/numpy/doc/swig/testTensor.py	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/testTensor.py	2007-04-05 22:20:15 UTC (rev 3672)
@@ -0,0 +1,244 @@
+#! /usr/bin/env python
+
+# System imports
+from   distutils.util import get_platform
+from   math           import sqrt
+import os
+import sys
+import unittest
+
+# Import NumPy
+import numpy as N
+major, minor = [ int(d) for d in N.__version__.split(".")[:2] ]
+if major == 0: BadListError = TypeError
+else:          BadListError = ValueError
+
+# Add the distutils-generated build directory to the python search path and then
+# import the extension module
+libDir = "lib.%s-%s" % (get_platform(), sys.version[:3])
+sys.path.insert(0,os.path.join("build", libDir))
+import Tensor
+
+######################################################################
+
+class TensorTestCase(unittest.TestCase):
+
+    def __init__(self, methodName="runTests"):
+        unittest.TestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+        self.result   = sqrt(28.0/8)
+
+    def testNorm(self):
+        "Test norm function"
+        print >>sys.stderr, self.typeStr, "... ",
+        norm = Tensor.__dict__[self.typeStr + "Norm"]
+        tensor = [[[0,1], [2,3]],
+                  [[3,2], [1,0]]]
+        if isinstance(self.result, int):
+            self.assertEquals(norm(tensor), self.result)
+        else:
+            self.assertAlmostEqual(norm(tensor), self.result, 6)
+
+    def testMax(self):
+        "Test max function"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = Tensor.__dict__[self.typeStr + "Max"]
+        tensor = [[[1,2], [3,4]],
+                  [[5,6], [7,8]]]
+        self.assertEquals(max(tensor), 8)
+
+    def testMaxNonContainer(self):
+        "Test max function with None"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = Tensor.__dict__[self.typeStr + "Max"]
+        self.assertRaises(TypeError, max, None)
+
+    def testMaxWrongDim(self):
+        "Test max function with a 1D array"
+        print >>sys.stderr, self.typeStr, "... ",
+        max = Tensor.__dict__[self.typeStr + "Max"]
+        self.assertRaises(TypeError, max, [0, -1, 2, -3])
+
+    def testMin(self):
+        "Test min function"
+        print >>sys.stderr, self.typeStr, "... ",
+        min = Tensor.__dict__[self.typeStr + "Min"]
+        tensor = [[[9,8], [7,6]],
+                  [[5,4], [3,2]]]
+        self.assertEquals(min(tensor), 2)
+
+    def testScale(self):
+        "Test scale function"
+        print >>sys.stderr, self.typeStr, "... ",
+        scale = Tensor.__dict__[self.typeStr + "Scale"]
+        tensor = N.array([[[1,0,1], [0,1,0], [1,0,1]],
+                          [[0,1,0], [1,0,1], [0,1,0]],
+                          [[1,0,1], [0,1,0], [1,0,1]]],self.typeCode)
+        scale(tensor,4)
+        self.assertEquals((tensor == [[[4,0,4], [0,4,0], [4,0,4]],
+                                      [[0,4,0], [4,0,4], [0,4,0]],
+                                      [[4,0,4], [0,4,0], [4,0,4]]]).all(), True)
+
+    def testFloor(self):
+        "Test floor function"
+        print >>sys.stderr, self.typeStr, "... ",
+        floor = Tensor.__dict__[self.typeStr + "Floor"]
+        tensor = N.array([[[1,2], [3,4]],
+                          [[5,6], [7,8]]],self.typeCode)
+        floor(tensor,4)
+        N.testing.assert_array_equal(tensor, N.array([[[4,4], [4,4]],
+                                                      [[5,6], [7,8]]]))
+
+    def testCeil(self):
+        "Test ceil function"
+        print >>sys.stderr, self.typeStr, "... ",
+        ceil = Tensor.__dict__[self.typeStr + "Ceil"]
+        tensor = N.array([[[9,8], [7,6]],
+                          [[5,4], [3,2]]],self.typeCode)
+        ceil(tensor,5)
+        N.testing.assert_array_equal(tensor, N.array([[[5,5], [5,5]],
+                                                      [[5,4], [3,2]]]))
+
+    def testLUSplit(self):
+        "Test luSplit function"
+        print >>sys.stderr, self.typeStr, "... ",
+        luSplit = Tensor.__dict__[self.typeStr + "LUSplit"]
+        lower, upper = luSplit([[[1,1], [1,1]],
+                                [[1,1], [1,1]]])
+        self.assertEquals((lower == [[[1,1], [1,0]],
+                                     [[1,0], [0,0]]]).all(), True)
+        self.assertEquals((upper == [[[0,0], [0,1]],
+                                     [[0,1], [1,1]]]).all(), True)
+
+######################################################################
+
+class scharTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "schar"
+        self.typeCode = "b"
+        self.result   = int(self.result)
+
+######################################################################
+
+class ucharTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "uchar"
+        self.typeCode = "B"
+        self.result   = int(self.result)
+
+######################################################################
+
+class shortTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "short"
+        self.typeCode = "h"
+        self.result   = int(self.result)
+
+######################################################################
+
+class ushortTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "ushort"
+        self.typeCode = "H"
+        self.result   = int(self.result)
+
+######################################################################
+
+class intTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "int"
+        self.typeCode = "i"
+        self.result   = int(self.result)
+
+######################################################################
+
+class uintTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "uint"
+        self.typeCode = "I"
+        self.result   = int(self.result)
+
+######################################################################
+
+class longTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "long"
+        self.typeCode = "l"
+        self.result   = int(self.result)
+
+######################################################################
+
+class ulongTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "ulong"
+        self.typeCode = "L"
+        self.result   = int(self.result)
+
+######################################################################
+
+class longLongTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "longLong"
+        self.typeCode = "q"
+        self.result   = int(self.result)
+
+######################################################################
+
+class ulongLongTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "ulongLong"
+        self.typeCode = "Q"
+        self.result   = int(self.result)
+
+######################################################################
+
+class floatTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "float"
+        self.typeCode = "f"
+
+######################################################################
+
+class doubleTestCase(TensorTestCase):
+    def __init__(self, methodName="runTest"):
+        TensorTestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+
+######################################################################
+
+if __name__ == "__main__":
+
+    # Build the test suite
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(    scharTestCase))
+    suite.addTest(unittest.makeSuite(    ucharTestCase))
+    suite.addTest(unittest.makeSuite(    shortTestCase))
+    suite.addTest(unittest.makeSuite(   ushortTestCase))
+    suite.addTest(unittest.makeSuite(      intTestCase))
+    suite.addTest(unittest.makeSuite(     uintTestCase))
+    suite.addTest(unittest.makeSuite(     longTestCase))
+    suite.addTest(unittest.makeSuite(    ulongTestCase))
+    suite.addTest(unittest.makeSuite( longLongTestCase))
+    suite.addTest(unittest.makeSuite(ulongLongTestCase))
+    suite.addTest(unittest.makeSuite(    floatTestCase))
+    suite.addTest(unittest.makeSuite(   doubleTestCase))
+
+    # Execute the test suite
+    print "Testing 3D Functions of Module Tensor"
+    print "NumPy version", N.__version__
+    print
+    result = unittest.TextTestRunner(verbosity=2).run(suite)
+    sys.exit(len(result.errors) + len(result.failures))


Property changes on: trunk/numpy/doc/swig/testTensor.py
___________________________________________________________________
Name: svn:executable
   + *

Added: trunk/numpy/doc/swig/testVector.py
===================================================================
--- trunk/numpy/doc/swig/testVector.py	2007-04-05 19:24:10 UTC (rev 3671)
+++ trunk/numpy/doc/swig/testVector.py	2007-04-05 22:20:15 UTC (rev 3672)
@@ -0,0 +1,226 @@
+#! /usr/bin/env python
+
+# System imports
+from   distutils.util import get_platform
+import os
+import sys
+import unittest
+
+# Import NumPy
+import numpy as N
+major, minor = [ int(d) for d in N.__version__.split(".")[:2] ]
+if major == 0: BadListError = TypeError
+else:          BadListError = ValueError
+
+# Add the distutils-generated build directory to the python search path and then
+# import the extension module
+libDir = "lib.%s-%s" % (get_platform(), sys.version[:3])
+sys.path.insert(0,os.path.join("build", libDir))
+import Vector
+
+######################################################################
+
+class VectorTestCase(unittest.TestCase):
+
+    def __init__(self, methodName="runTest"):
+        unittest.TestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+
+    def testLength(self):
+        "Test length function"
+        print >>sys.stderr, self.typeStr, "... ",
+        length = Vector.__dict__[self.typeStr + "Length"]
+        self.assertEquals(length([5, 12, 0]), 13)
+
+    def testLengthBad(self):
+        "Test length function for wrong size"
+        print >>sys.stderr, self.typeStr, "... ",
+        length = Vector.__dict__[self.typeStr + "Length"]
+        self.assertRaises(TypeError, length, [5, 12])
+
+    def testProd(self):
+        "Test prod function"
+        print >>sys.stderr, self.typeStr, "... ",
+        prod = Vector.__dict__[self.typeStr + "Prod"]
+        self.assertEquals(prod([1,2,3,4]), 24)
+
+    def testProdNonContainer(self):
+        "Test prod function with None"
+        print >>sys.stderr, self.typeStr, "... ",
+        prod = Vector.__dict__[self.typeStr + "Prod"]
+        self.assertRaises(TypeError, prod, None)
+
+    def testSum(self):
+        "Test sum function"
+        print >>sys.stderr, self.typeStr, "... ",
+        sum = Vector.__dict__[self.typeStr + "Sum"]
+        self.assertEquals(sum([5,6,7,8]), 26)
+
+    def testReverse(self):
+        "Test reverse function"
+        print >>sys.stderr, self.typeStr, "... ",
+        reverse = Vector.__dict__[self.typeStr + "Reverse"]
+        vector = N.array([1,2,4],self.typeCode)
+        reverse(vector)
+        self.assertEquals((vector == [4,2,1]).all(), True)
+
+    def testOnes(self):
+        "Test ones function"
+        print >>sys.stderr, self.typeStr, "... ",
+        ones = Vector.__dict__[self.typeStr + "Ones"]
+        myArray = N.zeros(5,self.typeCode)
+        ones(myArray)
+        N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
+
+    def testZeros(self):
+        "Test zeros function"
+        print >>sys.stderr, self.typeStr, "... ",
+        zeros = Vector.__dict__[self.typeStr + "Zeros"]
+        myArray = N.ones(5,self.typeCode)
+        zeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testEOSplit(self):
+        "Test eoSplit function"
+        print >>sys.stderr, self.typeStr, "... ",
+        eoSplit = Vector.__dict__[self.typeStr + "EOSplit"]
+        even, odd = eoSplit([1,2,3])
+        self.assertEquals((even == [1,0,3]).all(), True)
+        self.assertEquals((odd  == [0,2,0]).all(), True)
+
+    def testTwos(self):
+        "Test twos function"
+        print >>sys.stderr, self.typeStr, "... ",
+        twos = Vector.__dict__[self.typeStr + "Twos"]
+        vector = twos(5)
+        self.assertEquals((vector == [2,2,2,2,2]).all(), True)
+
+    def testThrees(self):
+        "Test threes function"
+        print >>sys.stderr, self.typeStr, "... ",
+        threes = Vector.__dict__[self.typeStr + "Threes"]
+        vector = threes(6)
+        self.assertEquals((vector == [3,3,3,3,3,3]).all(), True)
+
+######################################################################
+
+class scharTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "schar"
+        self.typeCode = "b"
+
+######################################################################
+
+class ucharTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "uchar"
+        self.typeCode = "B"
+
+######################################################################
+
+class shortTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "short"
+        self.typeCode = "h"
+
+######################################################################
+
+class ushortTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "ushort"
+        self.typeCode = "H"
+
+######################################################################
+
+class intTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "int"
+        self.typeCode = "i"
+
+######################################################################
+
+class uintTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "uint"
+        self.typeCode = "I"
+
+######################################################################
+
+class longTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "long"
+        self.typeCode = "l"
+
+######################################################################
+
+class ulongTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "ulong"
+        self.typeCode = "L"
+
+######################################################################
+
+class longLongTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "longLong"
+        self.typeCode = "q"
+
+######################################################################
+
+class ulongLongTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "ulongLong"
+        self.typeCode = "Q"
+
+######################################################################
+
+class floatTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "float"
+        self.typeCode = "f"
+
+######################################################################
+
+class doubleTestCase(VectorTestCase):
+    def __init__(self, methodName="runTest"):
+        VectorTestCase.__init__(self, methodName)
+        self.typeStr  = "double"
+        self.typeCode = "d"
+
+######################################################################
+
+if __name__ == "__main__":
+
+    # Build the test suite
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(    scharTestCase))
+    suite.addTest(unittest.makeSuite(    ucharTestCase))
+    suite.addTest(unittest.makeSuite(    shortTestCase))
+    suite.addTest(unittest.makeSuite(   ushortTestCase))
+    suite.addTest(unittest.makeSuite(      intTestCase))
+    suite.addTest(unittest.makeSuite(     uintTestCase))
+    suite.addTest(unittest.makeSuite(     longTestCase))
+    suite.addTest(unittest.makeSuite(    ulongTestCase))
+    suite.addTest(unittest.makeSuite( longLongTestCase))
+    suite.addTest(unittest.makeSuite(ulongLongTestCase))
+    suite.addTest(unittest.makeSuite(    floatTestCase))
+    suite.addTest(unittest.makeSuite(   doubleTestCase))
+
+    # Execute the test suite
+    print "Testing 1D Functions of Module Vector"
+    print "NumPy version", N.__version__
+    print
+    result = unittest.TextTestRunner(verbosity=2).run(suite)
+    sys.exit(len(result.errors) + len(result.failures))


Property changes on: trunk/numpy/doc/swig/testVector.py
___________________________________________________________________
Name: svn:executable
   + *



More information about the Numpy-svn mailing list